{
  "info": {
    "_postman_id": "4f622f31-328a-4506-95bd-66359cfbe749",
    "name": "Test Explore With Me - Main service",
    "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json",
    "_exporter_id": "13708500",
    "_collection_link": "https://universal-shadow-295426.postman.co/workspace/My-Workspace~4200f6aa-0504-44b1-8a1d-707d0dcbd5ce/collection/13708500-4f622f31-328a-4506-95bd-66359cfbe749?action=share&creator=13708500&source=collection_link"
  },
  "item": [
    {
      "name": "Validation",
      "item": [
        {
          "name": "Event",
          "item": [
            {
              "name": "Required query params",
              "item": [
                {
                  "name": "Добавление запроса от текущего пользователя на участие в событии без обязательного query params",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        const submittedUser = await api.addUser(rnd.getUser());\r",
                          "        pm.request.removeQueryParams(['eventId']);\r",
                          "        pm.collectionVariables.set('uid', submittedUser.id);\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            // выполняем наш скрипт\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/requests",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "requests"
                      ],
                      "query": [
                        {
                          "key": "eventId",
                          "value": "0",
                          "description": "(Required) id события",
                          "disabled": true
                        }
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        }
                      ]
                    },
                    "description": "Обратите внимание:\n- нельзя добавить повторный запрос\n- инициатор события не может добавить запрос на участие в своём событии\n- нельзя участвовать в неопубликованном событии\n- если у события достигнут лимит запросов на участие - необходимо вернуть ошибку\n- если для события отключена пре-модерация запросов на участие, то запрос должен автоматически перейти в состояние подтвержденного"
                  },
                  "response": []
                }
              ]
            },
            {
              "name": "Unrequired query params",
              "item": [
                {
                  "name": "Получение событий, добавленных текущим пользователем без нескольких Query params",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        pm.collectionVariables.set(\"uid\", user.id)\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        const event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.ok;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});"
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "GET",
                    "header": [
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/events",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "events"
                      ],
                      "query": [
                        {
                          "key": "from",
                          "value": "0",
                          "description": "количество элементов, которые нужно пропустить для формирования текущего набора",
                          "disabled": true
                        },
                        {
                          "key": "size",
                          "value": "1000",
                          "description": "количество элементов в наборе",
                          "disabled": true
                        }
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        }
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Получение событий с возможностью фильтрации без нескольких Query params",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        let event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                          "        event = await api.publishEvent(event.id);\r",
                          "        pm.request.removeQueryParams(['text', 'categories', 'paid']);\r",
                          "        pm.request.addQueryParams([`text=` + event.annotation, 'categories=' + category.id, 'paid=' + event.paid]);\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            // выполняем наш скрипт\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.ok;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});"
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "GET",
                    "header": [
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "url": {
                      "raw": "{{baseUrl}}/events",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "events"
                      ],
                      "query": [
                        {
                          "key": "text",
                          "value": "0",
                          "description": "текст для поиска в содержимом аннотации и подробном описании события",
                          "disabled": true
                        },
                        {
                          "key": "categories",
                          "value": "0",
                          "description": "список идентификаторов категорий в которых будет вестись поиск",
                          "disabled": true
                        },
                        {
                          "key": "paid",
                          "value": "true",
                          "description": "поиск только платных/бесплатных событий",
                          "disabled": true
                        },
                        {
                          "key": "rangeStart",
                          "value": "2022-01-06%2013%3A30%3A38",
                          "description": "дата и время не раньше которых должно произойти событие",
                          "disabled": true
                        },
                        {
                          "key": "rangeEnd",
                          "value": "2097-09-06%2013%3A30%3A38",
                          "description": "дата и время не позже которых должно произойти событие",
                          "disabled": true
                        },
                        {
                          "key": "onlyAvailable",
                          "value": "false",
                          "description": "только события у которых не исчерпан лимит запросов на участие",
                          "disabled": true
                        },
                        {
                          "key": "sort",
                          "value": "EVENT_DATE",
                          "description": "Вариант сортировки: по дате события или по количеству просмотров",
                          "disabled": true
                        },
                        {
                          "key": "from",
                          "value": "0",
                          "description": "количество событий, которые нужно пропустить для формирования текущего набора",
                          "disabled": true
                        },
                        {
                          "key": "size",
                          "value": "1000",
                          "description": "количество событий в наборе",
                          "disabled": true
                        }
                      ]
                    },
                    "description": "Обратите внимание: \n- это публичный эндпоинт, соответственно в выдаче должны быть только опубликованные события\n- текстовый поиск (по аннотации и подробному описанию) должен быть без учета регистра букв\n- если в запросе не указан диапазон дат [rangeStart-rangeEnd], то нужно выгружать события, которые произойдут позже текущей даты и времени\n- информация о каждом событии должна включать в себя количество просмотров и количество уже одобренных заявок на участие\n- информацию о том, что по этому эндпоинту был осуществлен и обработан запрос, нужно сохранить в сервисе статистики"
                  },
                  "response": []
                }
              ]
            },
            {
              "name": "Required params in body",
              "item": [
                {
                  "name": "Добавление события без поля description",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let event;\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        pm.collectionVariables.set(\"uid\", user.id)\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        event = rnd.getEvent(category.id);\r",
                          "        delete event[\"description\"];\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(event),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/events",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "events"
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        }
                      ]
                    },
                    "description": "Обратите внимание: дата и время на которые намечено событие не может быть раньше, чем через два часа от текущего момента"
                  },
                  "response": []
                },
                {
                  "name": "Добавление события с пустым описанием",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let event;\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        pm.collectionVariables.set(\"uid\", user.id)\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        event = rnd.getEvent(category.id);\r",
                          "        event[\"description\"] = '';\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(event),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/events",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "events"
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        }
                      ]
                    },
                    "description": "Обратите внимание: дата и время на которые намечено событие не может быть раньше, чем через два часа от текущего момента"
                  },
                  "response": []
                },
                {
                  "name": "Добавление события со строкой из пробелов в качестве описания",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let event;\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        pm.collectionVariables.set(\"uid\", user.id)\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        event = rnd.getEvent(category.id);\r",
                          "        event[\"description\"] = '      ';\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(event),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/events",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "events"
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        }
                      ]
                    },
                    "description": "Обратите внимание: дата и время на которые намечено событие не может быть раньше, чем через два часа от текущего момента"
                  },
                  "response": []
                },
                {
                  "name": "Добавление события без поля annotation",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let event;\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        pm.collectionVariables.set(\"uid\", user.id)\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        event = rnd.getEvent(category.id);\r",
                          "        delete event[\"annotation\"];\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(event),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/events",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "events"
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        }
                      ]
                    },
                    "description": "Обратите внимание: дата и время на которые намечено событие не может быть раньше, чем через два часа от текущего момента"
                  },
                  "response": []
                },
                {
                  "name": "Добавление события с пустой аннотацией",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let event;\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        pm.collectionVariables.set(\"uid\", user.id)\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        event = rnd.getEvent(category.id);\r",
                          "        event[\"annotation\"] = '';\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(event),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/events",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "events"
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        }
                      ]
                    },
                    "description": "Обратите внимание: дата и время на которые намечено событие не может быть раньше, чем через два часа от текущего момента"
                  },
                  "response": []
                },
                {
                  "name": "Добавление события со строкой из пробелов в качестве аннотации",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let event;\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        pm.collectionVariables.set(\"uid\", user.id)\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        event = rnd.getEvent(category.id);\r",
                          "        event[\"annotation\"] = '      ';\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(event),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/events",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "events"
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        }
                      ]
                    },
                    "description": "Обратите внимание: дата и время на которые намечено событие не может быть раньше, чем через два часа от текущего момента"
                  },
                  "response": []
                }
              ]
            },
            {
              "name": "Misc tests",
              "item": [
                {
                  "name": "Отклонение публикации события",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let new_event, event;\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                          "        pm.sendRequest({\r",
                          "            url : \"http://localhost:8080/admin/events/\" + event.id,\r",
                          "            method : \"PATCH\",\r",
                          "            header: { \"Content-Type\": \"application/json\" },\r",
                          "            body: JSON.stringify({\r",
                          "                stateAction: \"REJECT_EVENT\"\r",
                          "            })\r",
                          "        }, (error, response) => {\r",
                          "\r",
                          "        });\r",
                          "        pm.collectionVariables.set(\"uid\", user.id);\r",
                          "        pm.collectionVariables.set(\"eid\", event.id);\r",
                          "        pm.collectionVariables.set(\"response\", event);\r",
                          "        pm.request.body.update({\r",
                          "            mode: 'raw',\r",
                          "            raw: JSON.stringify({\r",
                          "                stateAction: \"SEND_TO_REVIEW\"\r",
                          "            }),\r",
                          "            options: { raw: { language: 'json' } }\r",
                          "        });\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.ok;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          "\r",
                          "const source = pm.collectionVariables.get(\"response\");\r",
                          "const target = pm.response.json();\r",
                          "\r",
                          "\r",
                          "pm.test(\"Событие должно содержать поля: id, title, annotation, category, paid, eventDate, initiator, description, participantLimit, state, createdOn, location, requestModeration\", function () {\r",
                          "pm.expect(target).to.have.property('id');\r",
                          "pm.expect(target).to.have.property('title');\r",
                          "pm.expect(target).to.have.property('annotation');\r",
                          "pm.expect(target).to.have.property('category');\r",
                          "pm.expect(target).to.have.property('paid');\r",
                          "pm.expect(target).to.have.property('eventDate');\r",
                          "pm.expect(target).to.have.property('initiator');\r",
                          "pm.expect(target).to.have.property('description');\r",
                          "pm.expect(target).to.have.property('participantLimit');\r",
                          "pm.expect(target).to.have.property('state');\r",
                          "pm.expect(target).to.have.property('createdOn');\r",
                          "pm.expect(target).to.have.property('location');\r",
                          "pm.expect(target).to.have.property('requestModeration');\r",
                          "});\r",
                          "\r",
                          "pm.test(\"Данные в ответе должны соответствовать данным в запросе\", function () {\r",
                          "    pm.expect(source.annotation).equal(target.annotation, 'Аннотация отменённого события должна соответствовать аннотации события до отмены');\r",
                          "    pm.expect(source.category.id).equal(target.category.id, 'Категория отменённого события должна соответствовать категории события до отмены');\r",
                          "    pm.expect(source.paid.toString()).equal(target.paid.toString(), 'Стоимость отменённого события должна соответствовать стоимости события до отмены');\r",
                          "    pm.expect(source.eventDate).equal(target.eventDate, 'Дата проведения отменённого события должна соответствовать дате проведения события до отмены');\r",
                          "    pm.expect(source.description).equal(target.description, 'Описание отменённого события должно соответствовать описанию события до отмены');\r",
                          "    pm.expect(source.title).equal(target.title, 'Название отменённого события должно соответствовать названию события до отмены');\r",
                          "    pm.expect(source.participantLimit.toString()).equal(target.participantLimit.toString(), 'Лимит участников отменённого события должен соответствовать лимиту участников события до отмены');\r",
                          "    pm.expect(source.paid.toString()).equal(target.paid.toString(), 'Стоимость отменённого события должна соответствовать стоимости события до отмены');\r",
                          "});\r",
                          "\r",
                          "pm.test(\"Событие должно иметь статус CANCELED при возвращении от администратора и статус PENDING после выполнения запроса\", function () {\r",
                          "    pm.expect(target.state).equal(\"PENDING\");\r",
                          "});"
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "PATCH",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/events/:eventId",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "events",
                        ":eventId"
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        },
                        {
                          "key": "eventId",
                          "value": "{{eid}}",
                          "description": "(Required) id отменяемого события"
                        }
                      ]
                    },
                    "description": "Обратите внимание: Отменить можно только событие в состоянии ожидания модерации."
                  },
                  "response": []
                },
                {
                  "name": "Попытка получения информации о событии по публичному эндпоинту без публикации",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        let event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                          "        pm.collectionVariables.set(\"eid\", event.id)\r",
                          "        pm.collectionVariables.set('response', event);\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            // выполняем наш скрипт\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 404 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.notFound;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "GET",
                    "header": [
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "url": {
                      "raw": "{{baseUrl}}/events/:id",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "events",
                        ":id"
                      ],
                      "variable": [
                        {
                          "key": "id",
                          "value": "{{eid}}",
                          "description": "(Required) id события"
                        }
                      ]
                    },
                    "description": "Обратите внимание:\n- событие должно быть опубликовано\n- информация о событии должна включать в себя количество просмотров и количество подтвержденных запросов\n- информацию о том, что по этому эндпоинту был осуществлен и обработан запрос, нужно сохранить в сервисе статистики"
                  },
                  "response": []
                },
                {
                  "name": "Поиск событий с проверкой параметров",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const user2 = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        let event = rnd.getEvent(category.id)\r",
                          "        event.requestModeration = true;\r",
                          "        event.participantLimit = 2;\r",
                          "        event = await api.addEvent(user.id, event);\r",
                          "        event = await api.publishEvent(event.id);\r",
                          "        pm.request.removeQueryParams(['users', 'categories']);\r",
                          "        pm.request.addQueryParams([`users=` + user.id, 'categories=' + category.id]);\r",
                          "        pm.collectionVariables.set('response', event);\r",
                          "        pm.sendRequest({\r",
                          "            url : \"http://localhost:8080/admin/events?users=\" + user.id +\"&states=PUBLISHED&categories=\" + category.id + \"&rangeStart=2022-01-06%2013%3A30%3A38&rangeEnd=2097-09-06%2013%3A30%3A38&from=0&size=1000\",\r",
                          "            method : \"GET\",\r",
                          "            header: { \"Content-Type\": \"application/json\" }\r",
                          "        }, (error, response) => {\r",
                          "            pm.collectionVariables.set('confirmedRequests', response.json()[0].confirmedRequests)\r",
                          "        });\r",
                          "        const requestToJoin = await api.publishParticipationRequest(event.id, user2.id);\r",
                          "        const confirmedRequest = await api.acceptParticipationRequest(event.id, user.id, requestToJoin.id);\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            // выполняем наш скрипт\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.ok;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          "\r",
                          "const source = pm.collectionVariables.get('response');\r",
                          "const target = pm.response.json()[0];\r",
                          "\r",
                          "pm.test(\"Событие должно содержать поля: id, title, annotation, category, paid, eventDate, initiator, views, confirmedRequests, description, participantLimit, state, createdOn, publishedOn, location, requestModeration\", function () {\r",
                          "pm.expect(target).to.have.property('id');\r",
                          "pm.expect(target).to.have.property('title');\r",
                          "pm.expect(target).to.have.property('annotation');\r",
                          "pm.expect(target).to.have.property('category');\r",
                          "pm.expect(target).to.have.property('paid');\r",
                          "pm.expect(target).to.have.property('eventDate');\r",
                          "pm.expect(target).to.have.property('initiator');\r",
                          "pm.expect(target).to.have.property('views');\r",
                          "pm.expect(target).to.have.property('confirmedRequests');\r",
                          "pm.expect(target).to.have.property('description');\r",
                          "pm.expect(target).to.have.property('participantLimit');\r",
                          "pm.expect(target).to.have.property('state');\r",
                          "pm.expect(target).to.have.property('createdOn');\r",
                          "pm.expect(target).to.have.property('publishedOn');\r",
                          "pm.expect(target).to.have.property('location');\r",
                          "pm.expect(target).to.have.property('requestModeration');\r",
                          "});\r",
                          "\r",
                          "pm.test(\"Данные в ответе должны соответствовать данным в запросе\", function () {\r",
                          "    pm.expect(source.annotation).equal(target.annotation, 'Аннотация события должна соответствовать искомому событию');\r",
                          "    pm.expect(source.category.id).equal(target.category.id, 'Идентификатор категории должен соответствовать искомой категории');\r",
                          "    pm.expect(source.paid.toString()).equal(target.paid.toString(), 'Стоимость посещения события должна соответствовать искомому событию');\r",
                          "    pm.expect(source.eventDate).equal(target.eventDate, 'Дата проведения события должна соответствовать дате искомого события');\r",
                          "    pm.expect(source.description).equal(target.description, 'Описание события должно соответствовать искомому событию');\r",
                          "    pm.expect(source.title).equal(target.title, 'Название события должно соответствовать искомому событию');\r",
                          "    pm.expect(source.participantLimit.toString()).equal(target.participantLimit.toString(), 'Число участников события должно соответствовать искомому событию');\r",
                          "    pm.expect(pm.collectionVariables.get('confirmedRequests')).equal(0);\r",
                          "    pm.expect(target.confirmedRequests).equal(1);\r",
                          "});"
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "GET",
                    "header": [
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "url": {
                      "raw": "{{baseUrl}}/admin/events?users=0&states=PUBLISHED&categories=0&rangeStart=2022-01-06%2013%3A30%3A38&rangeEnd=2097-09-06%2013%3A30%3A38&from=0&size=1000",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "events"
                      ],
                      "query": [
                        {
                          "key": "users",
                          "value": "0",
                          "description": "список id пользователей, чьи события нужно найти"
                        },
                        {
                          "key": "states",
                          "value": "PUBLISHED",
                          "description": "список состояний в которых находятся искомые события"
                        },
                        {
                          "key": "categories",
                          "value": "0",
                          "description": "список id категорий в которых будет вестись поиск"
                        },
                        {
                          "key": "rangeStart",
                          "value": "2022-01-06%2013%3A30%3A38",
                          "description": "дата и время не раньше которых должно произойти событие"
                        },
                        {
                          "key": "rangeEnd",
                          "value": "2097-09-06%2013%3A30%3A38",
                          "description": "дата и время не позже которых должно произойти событие"
                        },
                        {
                          "key": "from",
                          "value": "0",
                          "description": "количество событий, которые нужно пропустить для формирования текущего набора"
                        },
                        {
                          "key": "size",
                          "value": "1000",
                          "description": "количество событий в наборе"
                        }
                      ]
                    },
                    "description": "Эндпоинт возвращает полную информацию обо всех событиях подходящих под переданные условия"
                  },
                  "response": []
                },
                {
                  "name": "Получение событий с возможностью фильтрации и проверкой на валидацию",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        \r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            // выполняем наш скрипт\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});"
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "GET",
                    "header": [
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "url": {
                      "raw": "{{baseUrl}}/events?text=0&categories=0&paid=true&rangeStart=2022-01-06%2013%3A30%3A38&rangeEnd=2007-09-06%2013%3A30%3A38&onlyAvailable=false&sort=EVENT_DATE&from=0&size=1000",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "events"
                      ],
                      "query": [
                        {
                          "key": "text",
                          "value": "0",
                          "description": "текст для поиска в содержимом аннотации и подробном описании события"
                        },
                        {
                          "key": "categories",
                          "value": "0",
                          "description": "список идентификаторов категорий в которых будет вестись поиск"
                        },
                        {
                          "key": "paid",
                          "value": "true",
                          "description": "поиск только платных/бесплатных событий"
                        },
                        {
                          "key": "rangeStart",
                          "value": "2022-01-06%2013%3A30%3A38",
                          "description": "дата и время не раньше которых должно произойти событие"
                        },
                        {
                          "key": "rangeEnd",
                          "value": "2007-09-06%2013%3A30%3A38",
                          "description": "дата и время не позже которых должно произойти событие"
                        },
                        {
                          "key": "onlyAvailable",
                          "value": "false",
                          "description": "только события у которых не исчерпан лимит запросов на участие"
                        },
                        {
                          "key": "sort",
                          "value": "EVENT_DATE",
                          "description": "Вариант сортировки: по дате события или по количеству просмотров"
                        },
                        {
                          "key": "from",
                          "value": "0",
                          "description": "количество событий, которые нужно пропустить для формирования текущего набора"
                        },
                        {
                          "key": "size",
                          "value": "1000",
                          "description": "количество событий в наборе"
                        }
                      ]
                    },
                    "description": "Обратите внимание: \n- это публичный эндпоинт, соответственно в выдаче должны быть только опубликованные события\n- текстовый поиск (по аннотации и подробному описанию) должен быть без учета регистра букв\n- если в запросе не указан диапазон дат [rangeStart-rangeEnd], то нужно выгружать события, которые произойдут позже текущей даты и времени\n- информация о каждом событии должна включать в себя количество просмотров и количество уже одобренных заявок на участие\n- информацию о том, что по этому эндпоинту был осуществлен и обработан запрос, нужно сохранить в сервисе статистики"
                  },
                  "response": []
                },
                {
                  "name": "Проверка работы поля views",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        let event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                          "        event = await api.publishEvent(event.id);\r",
                          "        await api.findEvent(event.id)\r",
                          "        await api.findEvent(event.id)\r",
                          "        pm.collectionVariables.set(\"eid\", event.id)\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            // выполняем наш скрипт\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.ok;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          "\r",
                          "\r",
                          "const target = pm.response.json();\r",
                          "\r",
                          "pm.test(\"Событие должно содержать поля: id, title, annotation, category, paid, eventDate, initiator, views, confirmedRequests, description, participantLimit, state, createdOn, publishedOn, location, requestModeration\", function () {\r",
                          "pm.expect(target).to.have.property('id');\r",
                          "pm.expect(target).to.have.property('title');\r",
                          "pm.expect(target).to.have.property('annotation');\r",
                          "pm.expect(target).to.have.property('category');\r",
                          "pm.expect(target).to.have.property('paid');\r",
                          "pm.expect(target).to.have.property('eventDate');\r",
                          "pm.expect(target).to.have.property('initiator');\r",
                          "pm.expect(target).to.have.property('views');\r",
                          "pm.expect(target).to.have.property('confirmedRequests');\r",
                          "pm.expect(target).to.have.property('description');\r",
                          "pm.expect(target).to.have.property('participantLimit');\r",
                          "pm.expect(target).to.have.property('state');\r",
                          "pm.expect(target).to.have.property('createdOn');\r",
                          "pm.expect(target).to.have.property('publishedOn');\r",
                          "pm.expect(target).to.have.property('location');\r",
                          "pm.expect(target).to.have.property('requestModeration');\r",
                          "});\r",
                          "\r",
                          "pm.test(\"Значение поля views должно увеличится на 1 после выполнения GET запроса с уникального IP к событию\", function () {\r",
                          "    pm.expect(target.views).equal(1);\r",
                          "    \r",
                          "});"
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "GET",
                    "header": [
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "url": {
                      "raw": "{{baseUrl}}/events/:id",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "events",
                        ":id"
                      ],
                      "variable": [
                        {
                          "key": "id",
                          "value": "{{eid}}",
                          "description": "(Required) id события"
                        }
                      ]
                    },
                    "description": "Обратите внимание:\n- событие должно быть опубликовано\n- информация о событии должна включать в себя количество просмотров и количество подтвержденных запросов\n- информацию о том, что по этому эндпоинту был осуществлен и обработан запрос, нужно сохранить в сервисе статистики"
                  },
                  "response": []
                },
                {
                  "name": "Добавление запроса на участие при participantLimit == 0",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        let eventBody = rnd.getEvent(category.id);\r",
                          "        eventBody['requestModeration'] = true\r",
                          "        eventBody['participantLimit'] = 0\r",
                          "        let event = await api.addEvent(user.id, eventBody);\r",
                          "        event = await api.publishEvent(event.id);\r",
                          "        const submittedUser = await api.addUser(rnd.getUser());\r",
                          "        pm.request.removeQueryParams(['eventId']);\r",
                          "        pm.request.addQueryParams([`eventId=` + event.id]);\r",
                          "        pm.collectionVariables.set('uid', submittedUser.id);\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            // выполняем наш скрипт\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 201 и данные в формате json\", function () {\r",
                          "    pm.response.to.have.status(201);   \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          "\r",
                          "const target = pm.response.json();\r",
                          "var query = {};\r",
                          "pm.request.url.query.all().forEach((param) => { query[param.key] = param.value});\r",
                          "\r",
                          "pm.test(\"Запрос на участие должен содержать поля: id, requester, event, status, created\", function () {\r",
                          "pm.expect(target).to.have.property('id');\r",
                          "pm.expect(target).to.have.property('requester');\r",
                          "pm.expect(target).to.have.property('event');\r",
                          "pm.expect(target).to.have.property('status');\r",
                          "pm.expect(target).to.have.property('created');\r",
                          "});\r",
                          "\r",
                          "pm.test(\"При создании у запроса на участие должен быть статус CONFIRMED\", function () {\r",
                          "    pm.expect(target.status).equal(\"CONFIRMED\");\r",
                          "});\r",
                          "\r",
                          "pm.test(\"Id ивента в запросе и в ответе должны совпадать\", function () {\r",
                          "    pm.expect(target.event.toString()).equal(query['eventId'].toString());\r",
                          "});"
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/requests?eventId=0",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "requests"
                      ],
                      "query": [
                        {
                          "key": "eventId",
                          "value": "0",
                          "description": "(Required) id события"
                        }
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        }
                      ]
                    },
                    "description": "Обратите внимание:\n- нельзя добавить повторный запрос\n- инициатор события не может добавить запрос на участие в своём событии\n- нельзя участвовать в неопубликованном событии\n- если у события достигнут лимит запросов на участие - необходимо вернуть ошибку\n- если для события отключена пре-модерация запросов на участие, то запрос должен автоматически перейти в состояние подтвержденного"
                  },
                  "response": []
                },
                {
                  "name": "Изменение даты события на уже наступившую",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        let event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                          "        pm.collectionVariables.set(\"eid\", event.id)\r",
                          "        pm.request.body.update({\r",
                          "            mode: 'raw',\r",
                          "            raw: JSON.stringify({\r",
                          "                eventDate : \"2020-10-11 23:10:05\"\r",
                          "            }),\r",
                          "            options: { raw: { language: 'json' } }\r",
                          "        });\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            // выполняем наш скрипт\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.have.status(400);\r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          "\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "PATCH",
                    "header": [
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}"
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/events/:eventId",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "events",
                        ":eventId"
                      ],
                      "variable": [
                        {
                          "key": "eventId",
                          "value": "{{eid}}",
                          "description": "(Required) id события"
                        }
                      ]
                    },
                    "description": "Обратите внимание:\n - дата начала события должна быть не ранее чем за час от даты публикации.\n- событие должно быть в состоянии ожидания публикации"
                  },
                  "response": []
                },
                {
                  "name": "Изменение события добавленного текущим пользователем. Изменение даты не неподходящую",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        const event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                          "        pm.collectionVariables.set(\"uid\", user.id);\r",
                          "        pm.collectionVariables.set(\"eid\", event.id);\r",
                          "        pm.collectionVariables.set(\"response\", event);\r",
                          "        pm.request.body.update({\r",
                          "            mode: 'raw',\r",
                          "            raw: JSON.stringify({\r",
                          "                eventDate : \"2020-10-11 23:10:05\"\r",
                          "            }),\r",
                          "            options: { raw: { language: 'json' } }\r",
                          "        });\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.have.status(400);\r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "PATCH",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/events/:eventId",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "events",
                        ":eventId"
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        },
                        {
                          "key": "eventId",
                          "value": "{{eid}}",
                          "description": "(Required) id отменяемого события"
                        }
                      ]
                    },
                    "description": "Обратите внимание: Отменить можно только событие в состоянии ожидания модерации."
                  },
                  "response": []
                },
                {
                  "name": "Добавление события на неподходящую дату",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let event;\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        pm.collectionVariables.set(\"uid\", user.id)\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        event = rnd.getEvent(category.id);\r",
                          "        event.eventDate = \"2020-12-31 15:10:05\";\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(event),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.have.status(400);\r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/events",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "events"
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        }
                      ]
                    },
                    "description": "Обратите внимание: дата и время на которые намечено событие не может быть раньше, чем через два часа от текущего момента"
                  },
                  "response": []
                }
              ]
            },
            {
              "name": "String length restrictions",
              "item": [
                {
                  "name": "Добавление нового события с description.length < 20",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let event;\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        pm.collectionVariables.set(\"uid\", user.id)\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        event = rnd.getEvent(category.id);\r",
                          "        event.description = rnd.getWord(19);\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(event),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/events",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "events"
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        }
                      ]
                    },
                    "description": "Обратите внимание: дата и время на которые намечено событие не может быть раньше, чем через два часа от текущего момента"
                  },
                  "response": []
                },
                {
                  "name": "Добавление нового события с description.length < 20",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let event;\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        pm.collectionVariables.set(\"uid\", user.id)\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        event = rnd.getEvent(category.id);\r",
                          "        event.description = rnd.getWord(19);\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(event),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/events",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "events"
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        }
                      ]
                    },
                    "description": "Обратите внимание: дата и время на которые намечено событие не может быть раньше, чем через два часа от текущего момента"
                  },
                  "response": []
                },
                {
                  "name": "Добавление нового события с annotation.length < 20",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let event;\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        pm.collectionVariables.set(\"uid\", user.id)\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        event = rnd.getEvent(category.id);\r",
                          "        event.annotation = rnd.getWord(19);\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(event),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/events",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "events"
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        }
                      ]
                    },
                    "description": "Обратите внимание: дата и время на которые намечено событие не может быть раньше, чем через два часа от текущего момента"
                  },
                  "response": []
                },
                {
                  "name": "Добавление нового события с annotation.length > 2000",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let event;\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        pm.collectionVariables.set(\"uid\", user.id)\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        event = rnd.getEvent(category.id);\r",
                          "        event.annotation = rnd.getWord(2001);\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(event),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/events",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "events"
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        }
                      ]
                    },
                    "description": "Обратите внимание: дата и время на которые намечено событие не может быть раньше, чем через два часа от текущего момента"
                  },
                  "response": []
                },
                {
                  "name": "Добавление нового события с description.length == 20 && annotation.length == 20 && title.length == 3",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let event;\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        pm.collectionVariables.set(\"uid\", user.id)\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        event = rnd.getEvent(category.id);\r",
                          "        event.description = rnd.getWord(20);\r",
                          "        event.annotation = rnd.getWord(20);\r",
                          "        event.title = rnd.getWord(3);\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(event),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 201 и данные в формате json\", function () {\r",
                          "    pm.response.to.have.status(201);\r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/events",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "events"
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        }
                      ]
                    },
                    "description": "Обратите внимание: дата и время на которые намечено событие не может быть раньше, чем через два часа от текущего момента"
                  },
                  "response": []
                },
                {
                  "name": "Добавление нового события с description.length == 7000 && annotation.length == 2000 && title.length == 120",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let event;\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        pm.collectionVariables.set(\"uid\", user.id)\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        event = rnd.getEvent(category.id);\r",
                          "        event.description = rnd.getWord(7000);\r",
                          "        event.annotation = rnd.getWord(2000);\r",
                          "        event.title = rnd.getWord(120);\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(event),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 201 и данные в формате json\", function () {\r",
                          "    pm.response.to.have.status(201);\r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/events",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "events"
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        }
                      ]
                    },
                    "description": "Обратите внимание: дата и время на которые намечено событие не может быть раньше, чем через два часа от текущего момента"
                  },
                  "response": []
                },
                {
                  "name": "Добавление нового события с title.length < 3",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let event;\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        pm.collectionVariables.set(\"uid\", user.id)\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        event = rnd.getEvent(category.id);\r",
                          "        event.title = rnd.getWord(2);\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(event),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/events",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "events"
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        }
                      ]
                    },
                    "description": "Обратите внимание: дата и время на которые намечено событие не может быть раньше, чем через два часа от текущего момента"
                  },
                  "response": []
                },
                {
                  "name": "Добавление нового события с title.length > 120",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let event;\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        pm.collectionVariables.set(\"uid\", user.id)\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        event = rnd.getEvent(category.id);\r",
                          "        event.title = rnd.getWord(121);\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(event),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/events",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "events"
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        }
                      ]
                    },
                    "description": "Обратите внимание: дата и время на которые намечено событие не может быть раньше, чем через два часа от текущего момента"
                  },
                  "response": []
                },
                {
                  "name": "Изменение заголовка события с  title.length ＜ 3 (admin endpoint)",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        let event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                          "        let event2 = rnd.getEvent(category.id)\r",
                          "        event2.title = rnd.getWord(2);\r",
                          "        pm.collectionVariables.set(\"eid\", event.id)\r",
                          "        pm.request.body.update({\r",
                          "            mode: 'raw',\r",
                          "            raw: event2,\r",
                          "            options: { raw: { language: 'json' } }\r",
                          "        });\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            // выполняем наш скрипт\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "PATCH",
                    "header": [
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}"
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/events/:eventId",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "events",
                        ":eventId"
                      ],
                      "variable": [
                        {
                          "key": "eventId",
                          "value": "{{eid}}",
                          "description": "(Required) id события"
                        }
                      ]
                    },
                    "description": "Обратите внимание:\n - дата начала события должна быть не ранее чем за час от даты публикации.\n- событие должно быть в состоянии ожидания публикации"
                  },
                  "response": []
                },
                {
                  "name": "Изменение заголовка события с  title.length > 120 (admin endpoint)",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        let event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                          "        let event2 = rnd.getEvent(category.id)\r",
                          "        event2.title = rnd.getWord(121);\r",
                          "        pm.collectionVariables.set(\"eid\", event.id)\r",
                          "        pm.request.body.update({\r",
                          "            mode: 'raw',\r",
                          "            raw: event2,\r",
                          "            options: { raw: { language: 'json' } }\r",
                          "        });\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            // выполняем наш скрипт\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "PATCH",
                    "header": [
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}"
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/events/:eventId",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "events",
                        ":eventId"
                      ],
                      "variable": [
                        {
                          "key": "eventId",
                          "value": "{{eid}}",
                          "description": "(Required) id события"
                        }
                      ]
                    },
                    "description": "Обратите внимание:\n - дата начала события должна быть не ранее чем за час от даты публикации.\n- событие должно быть в состоянии ожидания публикации"
                  },
                  "response": []
                },
                {
                  "name": "Изменение описания события с  description.length ＜ 20 (admin endpoint)",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        let event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                          "        let event2 = rnd.getEvent(category.id)\r",
                          "        event2.description = rnd.getWord(19);\r",
                          "        pm.collectionVariables.set(\"eid\", event.id)\r",
                          "        pm.request.body.update({\r",
                          "            mode: 'raw',\r",
                          "            raw: event2,\r",
                          "            options: { raw: { language: 'json' } }\r",
                          "        });\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            // выполняем наш скрипт\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "PATCH",
                    "header": [
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}"
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/events/:eventId",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "events",
                        ":eventId"
                      ],
                      "variable": [
                        {
                          "key": "eventId",
                          "value": "{{eid}}",
                          "description": "(Required) id события"
                        }
                      ]
                    },
                    "description": "Обратите внимание:\n - дата начала события должна быть не ранее чем за час от даты публикации.\n- событие должно быть в состоянии ожидания публикации"
                  },
                  "response": []
                },
                {
                  "name": "Изменение описания события с description.length > 7000 (admin endpoint)",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        let event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                          "        let event2 = rnd.getEvent(category.id)\r",
                          "        event2.description = rnd.getWord(7001);\r",
                          "        pm.collectionVariables.set(\"eid\", event.id)\r",
                          "        pm.request.body.update({\r",
                          "            mode: 'raw',\r",
                          "            raw: event2,\r",
                          "            options: { raw: { language: 'json' } }\r",
                          "        });\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            // выполняем наш скрипт\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "PATCH",
                    "header": [
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}"
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/events/:eventId",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "events",
                        ":eventId"
                      ],
                      "variable": [
                        {
                          "key": "eventId",
                          "value": "{{eid}}",
                          "description": "(Required) id события"
                        }
                      ]
                    },
                    "description": "Обратите внимание:\n - дата начала события должна быть не ранее чем за час от даты публикации.\n- событие должно быть в состоянии ожидания публикации"
                  },
                  "response": []
                },
                {
                  "name": "Изменение аннотации события с annotation.length < 20 (admin endpoint)",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        let event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                          "        let event2 = rnd.getEvent(category.id)\r",
                          "        event2.annotation = rnd.getWord(19);\r",
                          "        pm.collectionVariables.set(\"eid\", event.id)\r",
                          "        pm.request.body.update({\r",
                          "            mode: 'raw',\r",
                          "            raw: event2,\r",
                          "            options: { raw: { language: 'json' } }\r",
                          "        });\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            // выполняем наш скрипт\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "PATCH",
                    "header": [
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}"
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/events/:eventId",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "events",
                        ":eventId"
                      ],
                      "variable": [
                        {
                          "key": "eventId",
                          "value": "{{eid}}",
                          "description": "(Required) id события"
                        }
                      ]
                    },
                    "description": "Обратите внимание:\n - дата начала события должна быть не ранее чем за час от даты публикации.\n- событие должно быть в состоянии ожидания публикации"
                  },
                  "response": []
                },
                {
                  "name": "Изменение аннотации события с annotation.length > 2000 (admin endpoint)",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        let event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                          "        let event2 = rnd.getEvent(category.id)\r",
                          "        event2.annotation = rnd.getWord(2001);\r",
                          "        pm.collectionVariables.set(\"eid\", event.id)\r",
                          "        pm.request.body.update({\r",
                          "            mode: 'raw',\r",
                          "            raw: event2,\r",
                          "            options: { raw: { language: 'json' } }\r",
                          "        });\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            // выполняем наш скрипт\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "PATCH",
                    "header": [
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}"
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/events/:eventId",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "events",
                        ":eventId"
                      ],
                      "variable": [
                        {
                          "key": "eventId",
                          "value": "{{eid}}",
                          "description": "(Required) id события"
                        }
                      ]
                    },
                    "description": "Обратите внимание:\n - дата начала события должна быть не ранее чем за час от даты публикации.\n- событие должно быть в состоянии ожидания публикации"
                  },
                  "response": []
                },
                {
                  "name": "Изменение события с description.length == 20 && annotation.length == 20 && title.length == 3 (admin endpoint)",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        let event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                          "        let event2 = rnd.getEvent(category.id)\r",
                          "        event2.annotation = rnd.getWord(20);\r",
                          "        event2.description = rnd.getWord(20);\r",
                          "        event2.title = rnd.getWord(3);\r",
                          "        pm.collectionVariables.set(\"eid\", event.id)\r",
                          "        pm.request.body.update({\r",
                          "            mode: 'raw',\r",
                          "            raw: event2,\r",
                          "            options: { raw: { language: 'json' } }\r",
                          "        });\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            // выполняем наш скрипт\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                          "    pm.response.to.have.status(200);\r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "PATCH",
                    "header": [
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}"
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/events/:eventId",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "events",
                        ":eventId"
                      ],
                      "variable": [
                        {
                          "key": "eventId",
                          "value": "{{eid}}",
                          "description": "(Required) id события"
                        }
                      ]
                    },
                    "description": "Обратите внимание:\n - дата начала события должна быть не ранее чем за час от даты публикации.\n- событие должно быть в состоянии ожидания публикации"
                  },
                  "response": []
                },
                {
                  "name": "Изменение события с description.length == 7000 && annotation.length == 2000 && title.length == 120 (admin endpoint)",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        let event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                          "        let event2 = rnd.getEvent(category.id)\r",
                          "        event2.annotation = rnd.getWord(2000);\r",
                          "        event2.description = rnd.getWord(7000);\r",
                          "        event2.title = rnd.getWord(120);\r",
                          "        pm.collectionVariables.set(\"eid\", event.id)\r",
                          "        pm.request.body.update({\r",
                          "            mode: 'raw',\r",
                          "            raw: event2,\r",
                          "            options: { raw: { language: 'json' } }\r",
                          "        });\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            // выполняем наш скрипт\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                          "    pm.response.to.have.status(200);\r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "PATCH",
                    "header": [
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}"
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/events/:eventId",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "events",
                        ":eventId"
                      ],
                      "variable": [
                        {
                          "key": "eventId",
                          "value": "{{eid}}",
                          "description": "(Required) id события"
                        }
                      ]
                    },
                    "description": "Обратите внимание:\n - дата начала события должна быть не ранее чем за час от даты публикации.\n- событие должно быть в состоянии ожидания публикации"
                  },
                  "response": []
                },
                {
                  "name": "Изменение заголовка события с title.length < 3 (user endpoint)",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        const event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                          "        pm.collectionVariables.set(\"uid\", user.id);\r",
                          "        pm.collectionVariables.set(\"eid\", event.id);\r",
                          "        pm.request.body.update({\r",
                          "            mode: 'raw',\r",
                          "            raw: JSON.stringify({\r",
                          "                title: rnd.getWord(2)\r",
                          "            }),\r",
                          "            options: { raw: { language: 'json' } }\r",
                          "        });\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "PATCH",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/events/:eventId",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "events",
                        ":eventId"
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        },
                        {
                          "key": "eventId",
                          "value": "{{eid}}",
                          "description": "(Required) id отменяемого события"
                        }
                      ]
                    },
                    "description": "Обратите внимание: Отменить можно только событие в состоянии ожидания модерации."
                  },
                  "response": []
                },
                {
                  "name": "Изменение заголовка события с title.length > 120 (user endpoint)",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        const event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                          "        pm.collectionVariables.set(\"uid\", user.id);\r",
                          "        pm.collectionVariables.set(\"eid\", event.id);\r",
                          "        pm.request.body.update({\r",
                          "            mode: 'raw',\r",
                          "            raw: JSON.stringify({\r",
                          "                title: rnd.getWord(121)\r",
                          "            }),\r",
                          "            options: { raw: { language: 'json' } }\r",
                          "        });\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "PATCH",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/events/:eventId",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "events",
                        ":eventId"
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        },
                        {
                          "key": "eventId",
                          "value": "{{eid}}",
                          "description": "(Required) id отменяемого события"
                        }
                      ]
                    },
                    "description": "Обратите внимание: Отменить можно только событие в состоянии ожидания модерации."
                  },
                  "response": []
                },
                {
                  "name": "Изменение описания события с description.length < 20 (user endpoint)",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        const event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                          "        pm.collectionVariables.set(\"uid\", user.id);\r",
                          "        pm.collectionVariables.set(\"eid\", event.id);\r",
                          "        pm.request.body.update({\r",
                          "            mode: 'raw',\r",
                          "            raw: JSON.stringify({\r",
                          "                description: rnd.getWord(19)\r",
                          "            }),\r",
                          "            options: { raw: { language: 'json' } }\r",
                          "        });\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "PATCH",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/events/:eventId",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "events",
                        ":eventId"
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        },
                        {
                          "key": "eventId",
                          "value": "{{eid}}",
                          "description": "(Required) id отменяемого события"
                        }
                      ]
                    },
                    "description": "Обратите внимание: Отменить можно только событие в состоянии ожидания модерации."
                  },
                  "response": []
                },
                {
                  "name": "Изменение описания события с description.length > 7000 (user endpoint)",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        const event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                          "        pm.collectionVariables.set(\"uid\", user.id);\r",
                          "        pm.collectionVariables.set(\"eid\", event.id);\r",
                          "        pm.request.body.update({\r",
                          "            mode: 'raw',\r",
                          "            raw: JSON.stringify({\r",
                          "                description: rnd.getWord(7001)\r",
                          "            }),\r",
                          "            options: { raw: { language: 'json' } }\r",
                          "        });\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "PATCH",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/events/:eventId",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "events",
                        ":eventId"
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        },
                        {
                          "key": "eventId",
                          "value": "{{eid}}",
                          "description": "(Required) id отменяемого события"
                        }
                      ]
                    },
                    "description": "Обратите внимание: Отменить можно только событие в состоянии ожидания модерации."
                  },
                  "response": []
                },
                {
                  "name": "Изменение аннотации события с annotation.length < 20 (user endpoint)",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        const event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                          "        pm.collectionVariables.set(\"uid\", user.id);\r",
                          "        pm.collectionVariables.set(\"eid\", event.id);\r",
                          "        pm.request.body.update({\r",
                          "            mode: 'raw',\r",
                          "            raw: JSON.stringify({\r",
                          "                annotation: rnd.getWord(19)\r",
                          "            }),\r",
                          "            options: { raw: { language: 'json' } }\r",
                          "        });\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "PATCH",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/events/:eventId",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "events",
                        ":eventId"
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        },
                        {
                          "key": "eventId",
                          "value": "{{eid}}",
                          "description": "(Required) id отменяемого события"
                        }
                      ]
                    },
                    "description": "Обратите внимание: Отменить можно только событие в состоянии ожидания модерации."
                  },
                  "response": []
                },
                {
                  "name": "Изменение аннотации события с annotation.length > 2000 (user endpoint)",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        const event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                          "        pm.collectionVariables.set(\"uid\", user.id);\r",
                          "        pm.collectionVariables.set(\"eid\", event.id);\r",
                          "        pm.request.body.update({\r",
                          "            mode: 'raw',\r",
                          "            raw: JSON.stringify({\r",
                          "                annotation: rnd.getWord(2001)\r",
                          "            }),\r",
                          "            options: { raw: { language: 'json' } }\r",
                          "        });\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "PATCH",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/events/:eventId",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "events",
                        ":eventId"
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        },
                        {
                          "key": "eventId",
                          "value": "{{eid}}",
                          "description": "(Required) id отменяемого события"
                        }
                      ]
                    },
                    "description": "Обратите внимание: Отменить можно только событие в состоянии ожидания модерации."
                  },
                  "response": []
                },
                {
                  "name": "Изменение события с description.length == 20 && annotation.length == 20 && title.length == 3 (user endpoint)",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        const event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                          "        pm.collectionVariables.set(\"uid\", user.id);\r",
                          "        pm.collectionVariables.set(\"eid\", event.id);\r",
                          "        pm.request.body.update({\r",
                          "            mode: 'raw',\r",
                          "            raw: JSON.stringify({\r",
                          "                description: rnd.getWord(20),\r",
                          "                annotation: rnd.getWord(20),\r",
                          "                title: rnd.getWord(3)\r",
                          "            }),\r",
                          "            options: { raw: { language: 'json' } }\r",
                          "        });\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                          "    pm.response.to.have.status(200);\r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "PATCH",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/events/:eventId",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "events",
                        ":eventId"
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        },
                        {
                          "key": "eventId",
                          "value": "{{eid}}",
                          "description": "(Required) id отменяемого события"
                        }
                      ]
                    },
                    "description": "Обратите внимание: Отменить можно только событие в состоянии ожидания модерации."
                  },
                  "response": []
                },
                {
                  "name": "Изменение события с description.length == 7000 && annotation.length == 2000 && title.length == 120 (user endpoint)",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        const event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                          "        pm.collectionVariables.set(\"uid\", user.id);\r",
                          "        pm.collectionVariables.set(\"eid\", event.id);\r",
                          "        pm.request.body.update({\r",
                          "            mode: 'raw',\r",
                          "            raw: JSON.stringify({\r",
                          "                description: rnd.getWord(7000),\r",
                          "                annotation: rnd.getWord(2000),\r",
                          "                title: rnd.getWord(120)\r",
                          "            }),\r",
                          "            options: { raw: { language: 'json' } }\r",
                          "        });\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                          "    pm.response.to.have.status(200);\r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "PATCH",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/events/:eventId",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "events",
                        ":eventId"
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        },
                        {
                          "key": "eventId",
                          "value": "{{eid}}",
                          "description": "(Required) id отменяемого события"
                        }
                      ]
                    },
                    "description": "Обратите внимание: Отменить можно только событие в состоянии ожидания модерации."
                  },
                  "response": []
                }
              ]
            },
            {
              "name": "Default values check",
              "item": [
                {
                  "name": "Добавление нового события без paid, participantLimit, requestModeration",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let usersArr = Array.from({length: 10}, () => rnd.getUser());\r",
                          "    let categoriesArr = Array.from({length: 10}, () => rnd.getCategory());\r",
                          "    let usersResponseArr = [], categoriesResponseArr = [], eventArr, eventResponseArr = [];\r",
                          "    try {\r",
                          "        for (const u of usersArr){\r",
                          "            usersResponseArr.push(await api.addUser(u));\r",
                          "        }\r",
                          "        for (const c of categoriesArr){\r",
                          "            categoriesResponseArr.push(await api.addCategory(c));\r",
                          "        }\r",
                          "        eventArr = Array.from(categoriesResponseArr, (x) => rnd.getEvent(x.id));\r",
                          "        for (let i = 0; i < 10; i++){\r",
                          "            delete eventArr[i].requestModeration;\r",
                          "            delete eventArr[i].paid;\r",
                          "            delete eventArr[i].participantLimit;\r",
                          "        }\r",
                          "        for (let i = 0; i < 10; i++){\r",
                          "            eventResponseArr.push(await api.addEvent(usersResponseArr[i].id, eventArr[i]));\r",
                          "        }\r",
                          "        pm.collectionVariables.set('responseArr', eventResponseArr)\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        pm.collectionVariables.set(\"uid\", user.id)\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        event = rnd.getEvent(category.id);\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(event),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 201 и данные в формате json\", function () {\r",
                          "    pm.response.to.have.status(201);  \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          "\r",
                          "const source = pm.collectionVariables.get('responseArr');\r",
                          "\r",
                          "\r",
                          "pm.test(\"У каждого созданного события paid должно принять значение по умолчанию(false)\", function () {\r",
                          "    source.forEach(function(x){pm.expect(x.paid).to.be.equal(false)});\r",
                          "});\r",
                          "\r",
                          "pm.test(\"У каждого созданного события participantLimit должен принять значение по умолчанию(0)\", function () {\r",
                          "    source.forEach(function(x){pm.expect(x.participantLimit).to.be.equal(0)});\r",
                          "});\r",
                          "\r",
                          "pm.test(\"У каждого созданного события requestModeration должно принять значение по умолчанию(true)\", function () {\r",
                          "    source.forEach(function(x){pm.expect(x.requestModeration).to.be.equal(true)});\r",
                          "});"
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/events",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "events"
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        }
                      ]
                    },
                    "description": "Обратите внимание: дата и время на которые намечено событие не может быть раньше, чем через два часа от текущего момента"
                  },
                  "response": []
                },
                {
                  "name": "Проверка на значения по-умолчанию from и size(event)",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let user, category, eventArr;\r",
                          "    try {\r",
                          "        user = await api.addUser(rnd.getUser());\r",
                          "        category = await api.addCategory(rnd.getCategory());\r",
                          "        eventArr = Array.from({length:11}, () => rnd.getEvent(category.id));\r",
                          "        for (let i = 0; i < 11; i++){\r",
                          "            await api.addEvent(user.id, eventArr[i]);\r",
                          "        }\r",
                          "        pm.sendRequest({\r",
                          "            url : \"http://localhost:8080/admin/events?from=0\",\r",
                          "            method : \"GET\",\r",
                          "            header: { \"Content-Type\": \"application/json\" }\r",
                          "        }, (error, response) => {pm.collectionVariables.set('source', response.json())});\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            // выполняем наш скрипт\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.ok;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          "\r",
                          "const target = pm.response.json();\r",
                          "const source = pm.collectionVariables.get('source');\r",
                          "\r",
                          "pm.test(\"Значение from по-умолчанию должно быть равным 0\", function () {\r",
                          "    pm.expect(target[0].id).to.be.equal(source[0].id, 'Запросы с from=0 и без него должны начинаться с одного и того же события');\r",
                          "});\r",
                          "\r",
                          "pm.test(\"Значение size по-умолчанию должно быть равным 10\", function () {\r",
                          "    pm.expect(target.length).to.be.equal(10);\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "GET",
                    "header": [
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "url": {
                      "raw": "{{baseUrl}}/admin/events",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "events"
                      ],
                      "query": [
                        {
                          "key": "users",
                          "value": "0",
                          "description": "список id пользователей, чьи события нужно найти",
                          "disabled": true
                        },
                        {
                          "key": "states",
                          "value": "PUBLISHED",
                          "description": "список состояний в которых находятся искомые события",
                          "disabled": true
                        },
                        {
                          "key": "categories",
                          "value": "0",
                          "description": "список id категорий в которых будет вестись поиск",
                          "disabled": true
                        },
                        {
                          "key": "rangeStart",
                          "value": "2022-01-06%2013%3A30%3A38",
                          "description": "дата и время не раньше которых должно произойти событие",
                          "disabled": true
                        },
                        {
                          "key": "rangeEnd",
                          "value": "2097-09-06%2013%3A30%3A38",
                          "description": "дата и время не позже которых должно произойти событие",
                          "disabled": true
                        },
                        {
                          "key": "from",
                          "value": "0",
                          "description": "количество событий, которые нужно пропустить для формирования текущего набора",
                          "disabled": true
                        },
                        {
                          "key": "size",
                          "value": "1000",
                          "description": "количество событий в наборе",
                          "disabled": true
                        }
                      ]
                    },
                    "description": "Эндпоинт возвращает полную информацию обо всех событиях подходящих под переданные условия"
                  },
                  "response": []
                },
                {
                  "name": "Получение событий, добавленных текущим пользователем. Проверка на значения по-умолчанию size и from",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let eventArr, user, category, eventResponseArr = [];\r",
                          "    try {\r",
                          "        user = await api.addUser(rnd.getUser());\r",
                          "        category = await api.addCategory(rnd.getCategory());\r",
                          "        eventArr = Array.from({length:11}, () => rnd.getEvent(category.id));\r",
                          "        for (let i = 0; i < 11; i++){\r",
                          "            eventResponseArr.push(await api.addEvent(user.id, eventArr[i]));\r",
                          "        }\r",
                          "        pm.collectionVariables.set('responseArr', eventResponseArr)\r",
                          "        pm.collectionVariables.set(\"uid\", user.id)\r",
                          "        pm.sendRequest({\r",
                          "            url : \"http://localhost:8080/users/\" + user.id + \"/events?from=0\",\r",
                          "            method : \"GET\",\r",
                          "            header: { \"Content-Type\": \"application/json\" }\r",
                          "        }, (error, response) => {pm.collectionVariables.set('source', response.json())});\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.ok;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          "\r",
                          "const target = pm.response.json();\r",
                          "const source = pm.collectionVariables.get('responseArr');\r",
                          "newSourceArr = Array.from(source, (x) => x.id);\r",
                          "const responseWithFrom = pm.collectionVariables.get('source');\r",
                          "\r",
                          "pm.test(\"Значение size по-умолчанию должно быть равным 10\", function () {\r",
                          "    pm.expect(target.length).to.equal(10);\r",
                          "});\r",
                          "\r",
                          "pm.test(\"Значение from по-умолчанию должно быть равным 0\", function () {\r",
                          "    pm.expect(target[0].id).to.be.equal(responseWithFrom[0].id, 'Запросы с from=0 и без него должны начинаться с одного и того же события');\r",
                          "});\r",
                          "\r",
                          "pm.test(\"Все найденные события должны быть в списке добавленных\", function () {\r",
                          "    source.forEach(function(x){pm.expect(newSourceArr).to.include(x.id)});\r",
                          "});"
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "GET",
                    "header": [
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "url": {
                      "raw": "{{baseUrl}}/users/:userId/events",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "users",
                        ":userId",
                        "events"
                      ],
                      "query": [
                        {
                          "key": "from",
                          "value": "0",
                          "description": "количество элементов, которые нужно пропустить для формирования текущего набора",
                          "disabled": true
                        },
                        {
                          "key": "size",
                          "value": "1000",
                          "description": "количество элементов в наборе",
                          "disabled": true
                        }
                      ],
                      "variable": [
                        {
                          "key": "userId",
                          "value": "{{uid}}",
                          "description": "(Required) id текущего пользователя"
                        }
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Получение событий с возможностью фильтрации. Проверка на значение по-умолчанию size",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let user, category, eventArr, eventResponseArr = [], publishEventResponseArr = [];\r",
                          "    try {\r",
                          "        user = await api.addUser(rnd.getUser());\r",
                          "        category = await api.addCategory(rnd.getCategory());\r",
                          "        eventArr = Array.from({length:11}, () => rnd.getEvent(category.id));\r",
                          "        for (let i = 0; i < 11; i++){\r",
                          "            eventResponseArr.push(await api.addEvent(user.id, eventArr[i]));\r",
                          "        }\r",
                          "        for (let i = 0; i < 11; i++){\r",
                          "            publishEventResponseArr.push(await api.publishEvent(eventResponseArr[i].id));\r",
                          "        }\r",
                          "        pm.collectionVariables.set('responseArr', eventResponseArr);\r",
                          "        pm.collectionVariables.set('catid', category.id);\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            // выполняем наш скрипт\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.ok;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          "\r",
                          "const target = pm.response.json();\r",
                          "const source = pm.collectionVariables.get('responseArr');\r",
                          "newSourceArr = Array.from(source, (x) => x.id);\r",
                          "\r",
                          "pm.test(\"Значение size по-умолчанию должно быть равным 10\", function () {\r",
                          "    pm.expect(target.length).to.equal(10);\r",
                          "});\r",
                          "\r",
                          "pm.test(\"Все найденные события должны быть в списке добавленных\", function () {\r",
                          "    source.forEach(function(x){pm.expect(newSourceArr).to.include(x.id)});\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "GET",
                    "header": [
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "url": {
                      "raw": "{{baseUrl}}/events?categories={{catid}}",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "events"
                      ],
                      "query": [
                        {
                          "key": "text",
                          "value": "0",
                          "description": "текст для поиска в содержимом аннотации и подробном описании события",
                          "disabled": true
                        },
                        {
                          "key": "categories",
                          "value": "{{catid}}",
                          "description": "список идентификаторов категорий в которых будет вестись поиск"
                        },
                        {
                          "key": "paid",
                          "value": "true",
                          "description": "поиск только платных/бесплатных событий",
                          "disabled": true
                        },
                        {
                          "key": "rangeStart",
                          "value": "2022-01-06%2013%3A30%3A38",
                          "description": "дата и время не раньше которых должно произойти событие",
                          "disabled": true
                        },
                        {
                          "key": "rangeEnd",
                          "value": "2097-09-06%2013%3A30%3A38",
                          "description": "дата и время не позже которых должно произойти событие",
                          "disabled": true
                        },
                        {
                          "key": "onlyAvailable",
                          "value": "false",
                          "description": "только события у которых не исчерпан лимит запросов на участие",
                          "disabled": true
                        },
                        {
                          "key": "sort",
                          "value": "EVENT_DATE",
                          "description": "Вариант сортировки: по дате события или по количеству просмотров",
                          "disabled": true
                        },
                        {
                          "key": "from",
                          "value": "0",
                          "description": "количество событий, которые нужно пропустить для формирования текущего набора",
                          "disabled": true
                        },
                        {
                          "key": "size",
                          "value": "1000",
                          "description": "количество событий в наборе",
                          "disabled": true
                        }
                      ]
                    },
                    "description": "Обратите внимание: \n- это публичный эндпоинт, соответственно в выдаче должны быть только опубликованные события\n- текстовый поиск (по аннотации и подробному описанию) должен быть без учета регистра букв\n- если в запросе не указан диапазон дат [rangeStart-rangeEnd], то нужно выгружать события, которые произойдут позже текущей даты и времени\n- информация о каждом событии должна включать в себя количество просмотров и количество уже одобренных заявок на участие\n- информацию о том, что по этому эндпоинту был осуществлен и обработан запрос, нужно сохранить в сервисе статистики"
                  },
                  "response": []
                }
              ]
            }
          ]
        },
        {
          "name": "Users",
          "item": [
            {
              "name": "Required query params",
              "item": []
            },
            {
              "name": "Unrequired query params",
              "item": [
                {
                  "name": "Поиск пользователей без нескольких Query params",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let compilation;\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        pm.collectionVariables.set(\"uid\", user.id)\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.ok;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});"
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "GET",
                    "header": [
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "url": {
                      "raw": "{{baseUrl}}/admin/users?ids={{uid}}",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "users"
                      ],
                      "query": [
                        {
                          "key": "ids",
                          "value": "{{uid}}",
                          "description": "id пользователей"
                        },
                        {
                          "key": "from",
                          "value": "0",
                          "description": "количество элементов, которые нужно пропустить для формирования текущего набора",
                          "disabled": true
                        },
                        {
                          "key": "size",
                          "value": "10",
                          "description": "количество элементов в наборе",
                          "disabled": true
                        }
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Поиск пользователей без параметра ids",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let compilation;\r",
                          "    try {\r",
                          "        let user1 = rnd.getUser();\r",
                          "        user1 = await api.addUser(user1);\r",
                          "\r",
                          "        let user2 = rnd.getUser()\r",
                          "        user2 = await api.addUser(user2);\r",
                          "        //pm.collectionVariables.set('fromId', user1.id);\r",
                          "        pm.collectionVariables.set('source1', user1);\r",
                          "        pm.collectionVariables.set('source2', user2);\r",
                          "\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.ok;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          "\r",
                          "const target = pm.response.json();\r",
                          "const source1 = pm.collectionVariables.get('source1');\r",
                          "const source2 = pm.collectionVariables.get('source2');\r",
                          "\r",
                          "pm.test(\"Пользователи должны содержать поля: id, name, email\", function () {\r",
                          "    pm.expect(target[target.length-2]).to.have.property('id');\r",
                          "    pm.expect(target[target.length-2]).to.have.property('name');\r",
                          "    pm.expect(target[target.length-2]).to.have.property('email');\r",
                          "    pm.expect(target[target.length-1]).to.have.property('id');\r",
                          "    pm.expect(target[target.length-1]).to.have.property('name');\r",
                          "    pm.expect(target[target.length-1]).to.have.property('email');\r",
                          "});\r",
                          "\r",
                          "pm.test(\"Данные последних двух пользователей должны совпадать с данными добавленных пользователей\", function () {\r",
                          "    pm.expect(target[target.length-2].id).to.equal(source1.id);\r",
                          "    pm.expect(target[target.length-2].name).to.equal(source1.name);\r",
                          "    pm.expect(target[target.length-2].email).to.equal(source1.email);\r",
                          "    pm.expect(target[target.length-1].id).to.equal(source2.id);\r",
                          "    pm.expect(target[target.length-1].name).to.equal(source2.name);\r",
                          "    pm.expect(target[target.length-1].email).to.equal(source2.email);\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "GET",
                    "header": [
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "url": {
                      "raw": "{{baseUrl}}/admin/users?from={{fromId}}&size=100000",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "users"
                      ],
                      "query": [
                        {
                          "key": "ids",
                          "value": "{{uid}}",
                          "description": "id пользователей",
                          "disabled": true
                        },
                        {
                          "key": "from",
                          "value": "{{fromId}}",
                          "description": "количество элементов, которые нужно пропустить для формирования текущего набора"
                        },
                        {
                          "key": "size",
                          "value": "100000",
                          "description": "количество элементов в наборе"
                        }
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Поиск событий без нескольких Query params",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        let event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                          "        event = await api.publishEvent(event.id);\r",
                          "        pm.request.removeQueryParams(['users', 'categories']);\r",
                          "        pm.request.addQueryParams([`users=` + user.id, 'categories=' + category.id]);\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            // выполняем наш скрипт\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.ok;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});"
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "GET",
                    "header": [
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "url": {
                      "raw": "{{baseUrl}}/admin/events",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "events"
                      ],
                      "query": [
                        {
                          "key": "users",
                          "value": "0",
                          "description": "список id пользователей, чьи события нужно найти",
                          "disabled": true
                        },
                        {
                          "key": "states",
                          "value": "PUBLISHED",
                          "description": "список состояний в которых находятся искомые события",
                          "disabled": true
                        },
                        {
                          "key": "categories",
                          "value": "0",
                          "description": "список id категорий в которых будет вестись поиск",
                          "disabled": true
                        },
                        {
                          "key": "rangeStart",
                          "value": "2022-01-06%2013%3A30%3A38",
                          "description": "дата и время не раньше которых должно произойти событие",
                          "disabled": true
                        },
                        {
                          "key": "rangeEnd",
                          "value": "2097-09-06%2013%3A30%3A38",
                          "description": "дата и время не позже которых должно произойти событие",
                          "disabled": true
                        },
                        {
                          "key": "from",
                          "value": "0",
                          "description": "количество событий, которые нужно пропустить для формирования текущего набора",
                          "disabled": true
                        },
                        {
                          "key": "size",
                          "value": "1000",
                          "description": "количество событий в наборе",
                          "disabled": true
                        }
                      ]
                    },
                    "description": "Эндпоинт возвращает полную информацию обо всех событиях подходящих под переданные условия"
                  },
                  "response": []
                }
              ]
            },
            {
              "name": "Required params in body",
              "item": [
                {
                  "name": "Добавление пользователя с электронной почтой, состоящей только из пробелов",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let user;\r",
                          "    try {\r",
                          "        user = rnd.getUser();\r",
                          "        user.email = \"    \";\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(user),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400\", function () {\r",
                          "    pm.response.to.have.status(400);\r",
                          "});"
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/users",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "users"
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Добавление пользователя с пустой электронной почтой",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let user;\r",
                          "    try {\r",
                          "        user = rnd.getUser();\r",
                          "        user.email = \"\";\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(user),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400\", function () {\r",
                          "    pm.response.to.have.status(400);\r",
                          "});"
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/users",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "users"
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Добавление пользователя без поля email",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let user;\r",
                          "    try {\r",
                          "        user = rnd.getUser();\r",
                          "        delete user.email;\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(user),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400\", function () {\r",
                          "    pm.response.to.have.status(400);\r",
                          "});"
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/users",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "users"
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Добавление пользователя с пустым именем",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let user;\r",
                          "    try {\r",
                          "        user = rnd.getUser();\r",
                          "        user.name = \"\";\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(user),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400\", function () {\r",
                          "    pm.response.to.have.status(400);\r",
                          "});"
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/users",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "users"
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Добавление пользователя с именем, состоящим только из пробелов",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let user;\r",
                          "    try {\r",
                          "        user = rnd.getUser();\r",
                          "        user.name = \"   \";\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(user),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400\", function () {\r",
                          "    pm.response.to.have.status(400);\r",
                          "});"
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/users",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "users"
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Добавление пользователя без поля name",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let user;\r",
                          "    try {\r",
                          "        user = rnd.getUser();\r",
                          "        delete user.name;\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(user),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400\", function () {\r",
                          "    pm.response.to.have.status(400);\r",
                          "});"
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/users",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "users"
                      ]
                    }
                  },
                  "response": []
                }
              ]
            },
            {
              "name": "Misc tests",
              "item": []
            },
            {
              "name": "String length restrictions",
              "item": [
                {
                  "name": "Добавление пользователя с name.length < 2",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let user;\r",
                          "    try {\r",
                          "        user = rnd.getUser();\r",
                          "        user.name = rnd.getWord(1);\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(user),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/users",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "users"
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Добавление пользователя с name.length == 2",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let user;\r",
                          "    try {\r",
                          "        user = rnd.getUser();\r",
                          "        user.name = rnd.getWord(2);\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(user),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 201 и данные в формате json\", function () {\r",
                          "    pm.response.to.have.status(201);\r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/users",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "users"
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Добавление пользователя с name.length > 250",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let user;\r",
                          "    try {\r",
                          "        user = rnd.getUser();\r",
                          "        user.name = rnd.getWord(251);\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(user),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/users",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "users"
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Добавление пользователя с name.length == 250",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let user;\r",
                          "    try {\r",
                          "        user = rnd.getUser();\r",
                          "        user.name = rnd.getWord(250);\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(user),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 201 и данные в формате json\", function () {\r",
                          "    pm.response.to.have.status(201);\r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/users",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "users"
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Добавление пользователя с email.length < 6",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let user;\r",
                          "    try {\r",
                          "        user = rnd.getUser();\r",
                          "        user.email = rnd.getWord(1) + '@a.r';\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(user),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/users",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "users"
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Добавление пользователя с email.length == 6",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let user;\r",
                          "    try {\r",
                          "        user = rnd.getUser();\r",
                          "        user.email = rnd.getWord(1) + '@a.ru';\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(user),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 201 и данные в формате json\", function () {\r",
                          "    pm.response.to.have.status(201);\r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/users",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "users"
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Добавление пользователя с email.localpart.length > 64",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let user;\r",
                          "    try {\r",
                          "        user = rnd.getUser();\r",
                          "        user.email = rnd.getWord(65) + '@a.ru';\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(user),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/users",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "users"
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Добавление пользователя с email.localpart.length == 64",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let user;\r",
                          "    try {\r",
                          "        user = rnd.getUser();\r",
                          "        user.email = rnd.getWord(59) + '@a.ru';\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(user),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 201 и данные в формате json\", function () {\r",
                          "    pm.response.to.have.status(201);\r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/users",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "users"
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Добавление пользователя с domain.part.length > 63",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let user;\r",
                          "    try {\r",
                          "        user = rnd.getUser();\r",
                          "        user.email = rnd.getWord(1) + '@' + rnd.getWord(64) + '.ru';\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(user),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/users",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "users"
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Добавление пользователя с domain.part.length == 63",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let user;\r",
                          "    try {\r",
                          "        user = rnd.getUser();\r",
                          "        user.email = rnd.getWord(1) + '@' + rnd.getWord(60) + '.ru';\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(user),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 201 и данные в формате json\", function () {\r",
                          "    pm.response.to.have.status(201);\r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/users",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "users"
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Добавление пользователя с email.length > 254",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let user;\r",
                          "    try {\r",
                          "        user = rnd.getUser();\r",
                          "        user.email = rnd.getWord(1) + '@' + rnd.getWord(63) + '.' + rnd.getWord(63) + '.' + rnd.getWord(63) + '.' + rnd.getWord(61);\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(user),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/users",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "users"
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Добавление пользователя с email.length == 254",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let user;\r",
                          "    try {\r",
                          "        user = rnd.getUser();\r",
                          "        user.email = rnd.getWord(1) + '@' + rnd.getWord(63) + '.' + rnd.getWord(63) + '.' + rnd.getWord(63) + '.' + rnd.getWord(60);\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(user),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 201 и данные в формате json\", function () {\r",
                          "    pm.response.to.have.status(201);\r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/users",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "users"
                      ]
                    }
                  },
                  "response": []
                }
              ]
            },
            {
              "name": "Default values check",
              "item": [
                {
                  "name": "Проверка на значения по-умолчанию from и size(user)",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        for (let i = 0; i < 11; i++){\r",
                          "            await api.addUser(rnd.getUser());\r",
                          "        }\r",
                          "        pm.sendRequest({\r",
                          "            url : \"http://localhost:8080/admin/users?from=0\",\r",
                          "            method : \"GET\",\r",
                          "            header: { \"Content-Type\": \"application/json\" }\r",
                          "        }, (error, response) => {pm.collectionVariables.set('source', response.json())});\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.ok;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          "\r",
                          "const target = pm.response.json();\r",
                          "const source = pm.collectionVariables.get('source');\r",
                          "\r",
                          "pm.test(\"Значение from по-умолчанию должно быть равным 0\", function () {\r",
                          "    pm.expect(target[0].id).to.be.equal(source[0].id, 'Запросы с from=0 и без него должны начинаться с одного и того же события');\r",
                          "});\r",
                          "\r",
                          "pm.test(\"Значение size по-умолчанию должно быть равным 10\", function () {\r",
                          "    pm.expect(target.length).to.be.equal(10);\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "GET",
                    "header": [
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "url": {
                      "raw": "{{baseUrl}}/admin/users",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "users"
                      ],
                      "query": [
                        {
                          "key": "ids",
                          "value": "{{uid}}",
                          "description": "id пользователей",
                          "disabled": true
                        },
                        {
                          "key": "ids",
                          "value": "-10833646",
                          "description": "id пользователей",
                          "disabled": true
                        },
                        {
                          "key": "from",
                          "value": "0",
                          "description": "количество элементов, которые нужно пропустить для формирования текущего набора",
                          "disabled": true
                        },
                        {
                          "key": "size",
                          "value": "10",
                          "description": "количество элементов в наборе",
                          "disabled": true
                        }
                      ]
                    }
                  },
                  "response": []
                }
              ]
            }
          ]
        },
        {
          "name": "Category",
          "item": [
            {
              "name": "Required query params",
              "item": []
            },
            {
              "name": "Unrequired params in body",
              "item": [
                {
                  "name": "Получение категорий без нескольких Query params",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.ok;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});"
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "GET",
                    "header": [
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "url": {
                      "raw": "{{baseUrl}}/categories",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "categories"
                      ],
                      "query": [
                        {
                          "key": "from",
                          "value": "0",
                          "description": "количество категорий, которые нужно пропустить для формирования текущего набора",
                          "disabled": true
                        },
                        {
                          "key": "size",
                          "value": "10000",
                          "description": "количество категорий в наборе",
                          "disabled": true
                        }
                      ]
                    }
                  },
                  "response": []
                }
              ]
            },
            {
              "name": "Required params in body",
              "item": [
                {
                  "name": "Добавление категории с именем, состоящим из пробелов",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let category;\r",
                          "    try {\r",
                          "        category = {name: '   '};\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(category),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [],
                    "body": {
                      "mode": "raw",
                      "raw": ""
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/categories",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "categories"
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Добавление категории с пустым полем name",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let category;\r",
                          "    try {\r",
                          "        category = {name: ''};\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(category),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [],
                    "body": {
                      "mode": "raw",
                      "raw": ""
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/categories",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "categories"
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Добавление категории без поля name",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let category;\r",
                          "    try {\r",
                          "        category = {};\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(category),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [],
                    "body": {
                      "mode": "raw",
                      "raw": ""
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/categories",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "categories"
                      ]
                    }
                  },
                  "response": []
                }
              ]
            },
            {
              "name": "Misc tests",
              "item": [
                {
                  "name": "Изменение категории с неизменными данными",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "    let category, categoryObj\r",
                          "    try {\r",
                          "        category = rnd.getCategory();\r",
                          "        categoryObj = await api.addCategory(category);\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "    pm.collectionVariables.set(\"catid\", Number(categoryObj.id))\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(category),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.ok;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          "\r",
                          "const source = JSON.parse(pm.request.body.raw);\r",
                          "const target = pm.response.json();\r",
                          "\r",
                          "pm.test(\"Категория должна содержать поля: id, name\", function () {\r",
                          "pm.expect(target).to.have.property('id');\r",
                          "pm.expect(target).to.have.property('name');\r",
                          "});\r",
                          "\r",
                          "pm.test(\"Данные в ответе должны соответствовать данным в запросе\", function () {\r",
                          "    pm.expect(target.id).to.not.be.null;\r",
                          "    pm.expect(source.name).equal(target.name, 'Название категории должно совпадать с отправленным');\r",
                          "});"
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "PATCH",
                    "header": [],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}"
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/categories/:catId",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "categories",
                        ":catId"
                      ],
                      "variable": [
                        {
                          "key": "catId",
                          "value": "{{catid}}"
                        }
                      ]
                    }
                  },
                  "response": []
                }
              ]
            },
            {
              "name": "String length restrictions",
              "item": [
                {
                  "name": "Добавление новой категории с name.length > 50",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let category;\r",
                          "    try {\r",
                          "        category = {'name': rnd.getWord(51)};\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(category),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/categories",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "categories"
                      ]
                    },
                    "description": "Обратите внимание: имя категории должно быть уникальным"
                  },
                  "response": []
                },
                {
                  "name": "Добавление новой категории с name.length == 50",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let category;\r",
                          "    try {\r",
                          "        category = {'name': rnd.getWord(50)};\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(category),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 201 и данные в формате json\", function () {\r",
                          "    pm.response.to.have.status(201);\r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/categories",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "categories"
                      ]
                    },
                    "description": "Обратите внимание: имя категории должно быть уникальным"
                  },
                  "response": []
                },
                {
                  "name": "Изменение имени категории с name.length > 50",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "    let category\r",
                          "    try {\r",
                          "        category = await api.addCategory(rnd.getCategory());\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "    pm.collectionVariables.set(\"catid\", Number(category.id))\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify({\r",
                          "            name : rnd.getWord(51)\r",
                          "        }),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "PATCH",
                    "header": [],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}"
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/categories/:catId",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "categories",
                        ":catId"
                      ],
                      "variable": [
                        {
                          "key": "catId",
                          "value": "{{catid}}"
                        }
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Изменение имени категории с name.length == 50",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "    let category\r",
                          "    try {\r",
                          "        category = await api.addCategory(rnd.getCategory());\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "    pm.collectionVariables.set(\"catid\", Number(category.id))\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify({\r",
                          "            name : rnd.getWord(50)\r",
                          "        }),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                          "    pm.response.to.have.status(200);\r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "PATCH",
                    "header": [],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}"
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/categories/:catId",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "categories",
                        ":catId"
                      ],
                      "variable": [
                        {
                          "key": "catId",
                          "value": "{{catid}}"
                        }
                      ]
                    }
                  },
                  "response": []
                }
              ]
            },
            {
              "name": "Default values check",
              "item": [
                {
                  "name": "Проверка на значения по-умолчанию from и size(category)",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        for (let i = 0; i < 11; i++){\r",
                          "            await api.addCategory(rnd.getCategory());\r",
                          "        }\r",
                          "        pm.sendRequest({\r",
                          "            url : \"http://localhost:8080/categories?from=0\",\r",
                          "            method : \"GET\",\r",
                          "            header: { \"Content-Type\": \"application/json\" }\r",
                          "        }, (error, response) => {pm.collectionVariables.set('source', response.json())});\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.ok;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          "\r",
                          "const target = pm.response.json();\r",
                          "const source = pm.collectionVariables.get('source');\r",
                          "\r",
                          "pm.test(\"Значение from по-умолчанию должно быть равным 0\", function () {\r",
                          "    pm.expect(target[0].id).to.be.equal(source[0].id, 'Запросы с from=0 и без него должны начинаться с одного и того же события');\r",
                          "});\r",
                          "\r",
                          "pm.test(\"Значение size по-умолчанию должно быть равным 10\", function () {\r",
                          "    pm.expect(target.length).to.be.equal(10);\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "GET",
                    "header": [
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "url": {
                      "raw": "{{baseUrl}}/categories",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "categories"
                      ],
                      "query": [
                        {
                          "key": "from",
                          "value": "0",
                          "description": "количество категорий, которые нужно пропустить для формирования текущего набора",
                          "disabled": true
                        },
                        {
                          "key": "size",
                          "value": "1000",
                          "description": "количество категорий в наборе",
                          "disabled": true
                        }
                      ]
                    }
                  },
                  "response": []
                }
              ]
            }
          ]
        },
        {
          "name": "Compilation",
          "item": [
            {
              "name": "Required query params",
              "item": []
            },
            {
              "name": "Unreqired params in body",
              "item": [
                {
                  "name": "Получение подборок событий без нескольких Query params",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        const compilation = await api.addCompilation(rnd.getCompilation());\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            // выполняем наш скрипт\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.ok;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});"
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "GET",
                    "header": [
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "url": {
                      "raw": "{{baseUrl}}/compilations",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "compilations"
                      ],
                      "query": [
                        {
                          "key": "pinned",
                          "value": "true",
                          "description": "искать только закрепленные/не закрепленные подборки",
                          "disabled": true
                        },
                        {
                          "key": "from",
                          "value": "0",
                          "description": "количество элементов, которые нужно пропустить для формирования текущего набора",
                          "disabled": true
                        },
                        {
                          "key": "size",
                          "value": "1000",
                          "description": "количество элементов в наборе",
                          "disabled": true
                        }
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Добавление новой подборки без параметра pinned",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let compilation;\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        const event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                          "        compilation = rnd.getCompilation(event.id);\r",
                          "        delete compilation['pinned'];\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(compilation),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 201 и данные в формате json\", function () {\r",
                          "    pm.response.to.have.status(201);\r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          "\r",
                          "const source = JSON.parse(pm.request.body.raw);\r",
                          "const target = pm.response.json();\r",
                          "\r",
                          "pm.test(\"Подборка должны содержать поля: id, title, pinned, events\", function () {\r",
                          "pm.expect(target).to.have.property('id');\r",
                          "pm.expect(target).to.have.property('title');\r",
                          "pm.expect(target).to.have.property('pinned');\r",
                          "pm.expect(target).to.have.property('events');\r",
                          "});\r",
                          "\r",
                          "pm.test(\"Данные в ответе должны соответствовать данным в запросе\", function () {\r",
                          "    pm.expect(target.id).to.not.be.null;\r",
                          "    pm.expect(target.title).to.be.a(\"string\");\r",
                          "    pm.expect(target.events).to.be.an(\"array\");\r",
                          "    pm.expect(target.pinned).equal(false);\r",
                          "\r",
                          "    pm.expect(source.events[0]).equal(target.events[0].id, 'Идентификаторы событий в подборке должен быть идентичен идентификаторам, указанным при создании подборки ');\r",
                          "    pm.expect(source.title).equal(target.title, 'Название подборки должно соответствовать указанному при создании');\r",
                          "});"
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/compilations",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "compilations"
                      ]
                    }
                  },
                  "response": []
                }
              ]
            },
            {
              "name": "Required params in body",
              "item": [
                {
                  "name": "Добавление подборки без поля title",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let compilation;\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        compilation = {\r",
                          "            \"pinned\":\"true\"};\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(compilation),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/compilations",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "compilations"
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Добавление подборки с пустым полем title",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let compilation;\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        compilation = {\r",
                          "            \"pinned\":\"true\",\r",
                          "            \"title\": \"\"};\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(compilation),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/compilations",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "compilations"
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Добавление подборки с пустой строкой в качестве названия",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let compilation;\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        compilation = {\r",
                          "            \"pinned\":\"true\",\r",
                          "            \"title\": \"    \"};\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(compilation),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/compilations",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "compilations"
                      ]
                    }
                  },
                  "response": []
                }
              ]
            },
            {
              "name": "Misc tests",
              "item": [
                {
                  "name": "Добавление подборки с проверкой связей многие-ко-многим",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let compilation;\r",
                          "    let compilation2;\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        const event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                          "        const event2 = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                          "        compilation = rnd.getCompilation(event.id, event2.id);\r",
                          "        compilation2 = rnd.getCompilation(event.id, event2.id);\r",
                          "        pm.sendRequest({\r",
                          "            url : \"http://localhost:8080/admin/compilations/\",\r",
                          "            method : \"POST\",\r",
                          "            header: { \"Content-Type\": \"application/json\" },\r",
                          "            body: JSON.stringify({\r",
                          "                events: compilation2.events,\r",
                          "                title: compilation2.title\r",
                          "            })\r",
                          "        }, (error, response) => {\r",
                          "\r",
                          "        });\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(compilation),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 201 и данные в формате json\", function () {\r",
                          "    pm.response.to.have.status(201);\r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          "\r",
                          "const source = JSON.parse(pm.request.body.raw);\r",
                          "const target = pm.response.json();\r",
                          "\r",
                          "pm.test(\"Подборка должны содержать поля: id, title, pinned, events\", function () {\r",
                          "pm.expect(target).to.have.property('id');\r",
                          "pm.expect(target).to.have.property('title');\r",
                          "pm.expect(target).to.have.property('pinned');\r",
                          "pm.expect(target).to.have.property('events');\r",
                          "});\r",
                          "\r",
                          "pm.test(\"Данные в ответе должны соответствовать данным в запросе\", function () {\r",
                          "    pm.expect(target.id).to.not.be.null;\r",
                          "    pm.expect(target.title).to.be.a(\"string\");\r",
                          "    pm.expect(target.events).to.be.an(\"array\");\r",
                          "    if (target.events[0].id < target.events[1].id){\r",
                          "        pm.expect(source.events[0]).equal(target.events[0].id, 'Идентификаторы событий в подборке должен быть идентичен идентификаторам, указанным при создании подборки ');\r",
                          "    } else {\r",
                          "        pm.expect(source.events[0]).equal(target.events[1].id, 'Идентификаторы событий в подборке должен быть идентичен идентификаторам, указанным при создании подборки ');\r",
                          "    }\r",
                          "    pm.expect(source.title).equal(target.title, 'Название подборки должно соответствовать указанному при создании');\r",
                          "});"
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/compilations",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "compilations"
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Добавление подборки без событий",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let compilation;\r",
                          "    try {\r",
                          "        const user = await api.addUser(rnd.getUser());\r",
                          "        const category = await api.addCategory(rnd.getCategory());\r",
                          "        compilation = rnd.getCompilation();\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(compilation),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 201 и данные в формате json\", function () {\r",
                          "    pm.response.to.have.status(201);\r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          "\r",
                          "const source = JSON.parse(pm.request.body.raw);\r",
                          "const target = pm.response.json();\r",
                          "\r",
                          "pm.test(\"Подборка должны содержать поля: id, title, pinned, events\", function () {\r",
                          "    pm.expect(target).to.have.property('id');\r",
                          "    pm.expect(target).to.have.property('title');\r",
                          "    pm.expect(target).to.have.property('pinned');\r",
                          "    pm.expect(target).to.have.property('events');\r",
                          "});\r",
                          "\r",
                          "pm.test(\"Данные в ответе должны соответствовать данным в запросе\", function () {\r",
                          "    pm.expect(target.id).to.not.be.null;\r",
                          "    pm.expect(target.title).to.be.a(\"string\");\r",
                          "    pm.expect(target.events).to.be.an(\"array\");\r",
                          "\r",
                          "    pm.expect(source.title).equal(target.title, 'Название подборки должно соответствовать указанному при создании');\r",
                          "});"
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/compilations",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "compilations"
                      ]
                    }
                  },
                  "response": []
                }
              ]
            },
            {
              "name": "String length restrictions",
              "item": [
                {
                  "name": "Добавление подборки с title.length > 50",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let compilation;\r",
                          "    try {\r",
                          "\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify({title: rnd.getWord(51)}),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/compilations",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "compilations"
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Добавление подборки с title.length == 50",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let compilation;\r",
                          "    try {\r",
                          "\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify({title: rnd.getWord(50)}),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 201 и данные в формате json\", function () {\r",
                          "    pm.response.to.have.status(201);\r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/compilations",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "compilations"
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Обновить названия подборки с title.length > 50",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        const compilation = await api.addCompilation(rnd.getCompilation());\r",
                          "        pm.collectionVariables.set('compid', compilation.id);\r",
                          "        pm.request.body.update({\r",
                          "            mode: 'raw',\r",
                          "            raw: JSON.stringify({\r",
                          "                title: rnd.getWord(51)\r",
                          "            }),\r",
                          "            options: { raw: { language: 'json' } }\r",
                          "        });\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            // выполняем наш скрипт\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 400 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.badRequest;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "PATCH",
                    "header": [],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}"
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/compilations/:compId",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "compilations",
                        ":compId"
                      ],
                      "variable": [
                        {
                          "key": "compId",
                          "value": "{{compid}}"
                        }
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Обновить названия подборки с title.length == 50",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        const compilation = await api.addCompilation(rnd.getCompilation());\r",
                          "        pm.collectionVariables.set('compid', compilation.id);\r",
                          "        pm.request.body.update({\r",
                          "            mode: 'raw',\r",
                          "            raw: JSON.stringify({\r",
                          "                title: rnd.getWord(50)\r",
                          "            }),\r",
                          "            options: { raw: { language: 'json' } }\r",
                          "        });\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            // выполняем наш скрипт\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                          "    pm.response.to.have.status(200);\r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "PATCH",
                    "header": [],
                    "body": {
                      "mode": "raw",
                      "raw": "{{request_body}}"
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/compilations/:compId",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "compilations",
                        ":compId"
                      ],
                      "variable": [
                        {
                          "key": "compId",
                          "value": "{{compid}}"
                        }
                      ]
                    }
                  },
                  "response": []
                }
              ]
            },
            {
              "name": "Default values check",
              "item": [
                {
                  "name": "Добавление подборки без pinned",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    let cArr = Array.from({length: 10}, () => rnd.getCompilation());\r",
                          "    let responseArr = [];\r",
                          "    try {\r",
                          "        cArr.forEach(function(x){ delete x.pinned });\r",
                          "        for (const c of cArr){\r",
                          "            responseArr.push(await api.addCompilation(c));\r",
                          "        }\r",
                          "        pm.collectionVariables.set('responseArr', responseArr);\r",
                          "        compilation = rnd.getCompilation();\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "\r",
                          "    pm.request.body.update({\r",
                          "        mode: 'raw',\r",
                          "        raw: JSON.stringify(compilation),\r",
                          "        options: { raw: { language: 'json' } }\r",
                          "    });\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 201 и данные в формате json\", function () {\r",
                          "    pm.response.to.have.status(201);\r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          "\r",
                          "const source = pm.collectionVariables.get('responseArr');\r",
                          "\r",
                          "\r",
                          "pm.test(\"У каждой из созданных подборок pinned должно принять значение по умолчанию(false)\", function () {\r",
                          "    source.forEach(function(x){pm.expect(x.pinned).to.be.equal(false)});\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "POST",
                    "header": [
                      {
                        "key": "Content-Type",
                        "value": "application/json"
                      },
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "body": {
                      "mode": "raw",
                      "raw": "",
                      "options": {
                        "raw": {
                          "language": "json"
                        }
                      }
                    },
                    "url": {
                      "raw": "{{baseUrl}}/admin/compilations",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "admin",
                        "compilations"
                      ]
                    }
                  },
                  "response": []
                },
                {
                  "name": "Проверка на значения по-умолчанию from и size(compilation)",
                  "event": [
                    {
                      "listen": "prerequest",
                      "script": {
                        "exec": [
                          "const main = async () => {\r",
                          "    const api = new API(pm);\r",
                          "    const rnd = new RandomUtils();\r",
                          "\r",
                          "    try {\r",
                          "        for (let i = 0; i < 11; i++){\r",
                          "            await api.addCompilation(rnd.getCompilation());\r",
                          "        }\r",
                          "        pm.sendRequest({\r",
                          "            url : \"http://localhost:8080/compilations?from=0\",\r",
                          "            method : \"GET\",\r",
                          "            header: { \"Content-Type\": \"application/json\" }\r",
                          "        }, (error, response) => {pm.collectionVariables.set('source', response.json())});\r",
                          "    } catch(err) {\r",
                          "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                          "    }\r",
                          "};\r",
                          "\r",
                          "const interval = setInterval(() => {}, 1000);\r",
                          "\r",
                          "setTimeout(async () => \r",
                          "    {\r",
                          "        try {\r",
                          "            // выполняем наш скрипт\r",
                          "            await main();\r",
                          "        } catch (e) {\r",
                          "            console.error(e);\r",
                          "        } finally {\r",
                          "            clearInterval(interval);\r",
                          "        }\r",
                          "    },  \r",
                          "    100 \r",
                          ");"
                        ],
                        "type": "text/javascript"
                      }
                    },
                    {
                      "listen": "test",
                      "script": {
                        "exec": [
                          "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                          "    pm.response.to.be.ok;    \r",
                          "    pm.response.to.be.withBody;\r",
                          "    pm.response.to.be.json;\r",
                          "});\r",
                          "\r",
                          "const target = pm.response.json();\r",
                          "const source = pm.collectionVariables.get('source');\r",
                          "\r",
                          "pm.test(\"Значение from по-умолчанию должно быть равным 0\", function () {\r",
                          "    pm.expect(target[0].id).to.be.equal(source[0].id, 'Запросы с from=0 и без него должны начинаться с одного и того же события');\r",
                          "});\r",
                          "\r",
                          "pm.test(\"Значение size по-умолчанию должно быть равным 10\", function () {\r",
                          "    pm.expect(target.length).to.be.equal(10);\r",
                          "});\r",
                          ""
                        ],
                        "type": "text/javascript"
                      }
                    }
                  ],
                  "request": {
                    "method": "GET",
                    "header": [
                      {
                        "key": "Accept",
                        "value": "application/json"
                      }
                    ],
                    "url": {
                      "raw": "{{baseUrl}}/compilations",
                      "host": [
                        "{{baseUrl}}"
                      ],
                      "path": [
                        "compilations"
                      ],
                      "query": [
                        {
                          "key": "pinned",
                          "value": "true",
                          "description": "искать только закрепленные/не закрепленные подборки",
                          "disabled": true
                        },
                        {
                          "key": "from",
                          "value": "0",
                          "description": "количество элементов, которые нужно пропустить для формирования текущего набора",
                          "disabled": true
                        },
                        {
                          "key": "size",
                          "value": "1000",
                          "description": "количество элементов в наборе",
                          "disabled": true
                        }
                      ]
                    }
                  },
                  "response": []
                }
              ]
            }
          ]
        }
      ]
    },
    {
      "name": "409 Conflict",
      "item": [
        {
          "name": "Попытка изменения имени категории на уже существующее",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "    let category1, category2\r",
                  "    try {\r",
                  "        category1 = await api.addCategory(rnd.getCategory());\r",
                  "        category2 = await api.addCategory(rnd.getCategory());\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "    pm.collectionVariables.set(\"catid\", category2.id)\r",
                  "    pm.request.body.update({\r",
                  "        mode: 'raw',\r",
                  "        raw: JSON.stringify({\r",
                  "            name : category1.name\r",
                  "        }),\r",
                  "        options: { raw: { language: 'json' } }\r",
                  "    });\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 409 и данные в формате json\", function () {\r",
                  "    pm.response.to.have.status(409);\r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "PATCH",
            "header": [
              {
                "key": "Content-Type",
                "value": "application/json"
              },
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "body": {
              "mode": "raw",
              "raw": "{{request_body}}",
              "options": {
                "raw": {
                  "language": "json"
                }
              }
            },
            "url": {
              "raw": "{{baseUrl}}/admin/categories/:catId",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "admin",
                "categories",
                ":catId"
              ],
              "variable": [
                {
                  "key": "catId",
                  "value": "{{catid}}"
                }
              ]
            },
            "description": "Обратите внимание: имя категории должно быть уникальным"
          },
          "response": []
        },
        {
          "name": "Добавление новой категории с занятым именем",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    let category;\r",
                  "    try {\r",
                  "        category = rnd.getCategory();\r",
                  "        await api.addCategory(category);\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "\r",
                  "    pm.request.body.update({\r",
                  "        mode: 'raw',\r",
                  "        raw: JSON.stringify(category),\r",
                  "        options: { raw: { language: 'json' } }\r",
                  "    });\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 409 и данные в формате json\", function () {\r",
                  "    pm.response.to.have.status(409);\r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "POST",
            "header": [
              {
                "key": "Content-Type",
                "value": "application/json"
              },
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "body": {
              "mode": "raw",
              "raw": "{{request_body}}",
              "options": {
                "raw": {
                  "language": "json"
                }
              }
            },
            "url": {
              "raw": "{{baseUrl}}/admin/categories",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "admin",
                "categories"
              ]
            },
            "description": "Обратите внимание: имя категории должно быть уникальным"
          },
          "response": []
        },
        {
          "name": "Добавление пользователя с занятым именем",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    let user;\r",
                  "    try {\r",
                  "        user = rnd.getUser();\r",
                  "        await api.addUser(user);\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "\r",
                  "    pm.request.body.update({\r",
                  "        mode: 'raw',\r",
                  "        raw: JSON.stringify(user),\r",
                  "        options: { raw: { language: 'json' } }\r",
                  "    });\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 409 и данные в формате json\", function () {\r",
                  "    pm.response.to.have.status(409);\r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "POST",
            "header": [
              {
                "key": "Content-Type",
                "value": "application/json"
              },
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "body": {
              "mode": "raw",
              "raw": "{{request_body}}",
              "options": {
                "raw": {
                  "language": "json"
                }
              }
            },
            "url": {
              "raw": "{{baseUrl}}/admin/users",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "admin",
                "users"
              ]
            }
          },
          "response": []
        },
        {
          "name": "Удаление категории с привязанными событиями",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        const event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                  "        pm.collectionVariables.set('catid', category.id);\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 409 и данные в формате json\", function () {\r",
                  "    pm.response.to.have.status(409);\r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "DELETE",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/admin/categories/:catId",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "admin",
                "categories",
                ":catId"
              ],
              "variable": [
                {
                  "key": "catId",
                  "value": "{{catid}}"
                }
              ]
            },
            "description": "Обратите внимание: с категорий не должно быть связано ни одного события."
          },
          "response": []
        },
        {
          "name": "Изменение имени категории на уже занятое",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "    let category1, category2\r",
                  "    try {\r",
                  "        category1 = await api.addCategory(rnd.getCategory());\r",
                  "        category2 = await api.addCategory(rnd.getCategory());\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "    pm.collectionVariables.set(\"catid\", Number(category1.id))\r",
                  "    pm.request.body.update({\r",
                  "        mode: 'raw',\r",
                  "        raw: JSON.stringify({\r",
                  "            name : category2.name\r",
                  "        }),\r",
                  "        options: { raw: { language: 'json' } }\r",
                  "    });\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 409 и данные в формате json\", function () {\r",
                  "    pm.response.to.have.status(409);\r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "PATCH",
            "header": [],
            "body": {
              "mode": "raw",
              "raw": "{{request_body}}"
            },
            "url": {
              "raw": "{{baseUrl}}/admin/categories/:catId",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "admin",
                "categories",
                ":catId"
              ],
              "variable": [
                {
                  "key": "catId",
                  "value": "{{catid}}"
                }
              ]
            }
          },
          "response": []
        },
        {
          "name": "Публикация уже опубликованного события",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        let event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                  "        event = await api.publishEvent(event.id);\r",
                  "        pm.collectionVariables.set(\"eid\", event.id)\r",
                  "        pm.request.body.update({\r",
                  "            mode: 'raw',\r",
                  "            raw: JSON.stringify({\r",
                  "                stateAction : \"PUBLISH_EVENT\"\r",
                  "            }),\r",
                  "            options: { raw: { language: 'json' } }\r",
                  "        });\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            // выполняем наш скрипт\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 409 и данные в формате json\", function () {\r",
                  "    pm.response.to.have.status(409);\r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "PATCH",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "body": {
              "mode": "raw",
              "raw": "{{request_body}}"
            },
            "url": {
              "raw": "{{baseUrl}}/admin/events/:eventId",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "admin",
                "events",
                ":eventId"
              ],
              "variable": [
                {
                  "key": "eventId",
                  "value": "{{eid}}",
                  "description": "(Required) id события"
                }
              ]
            },
            "description": "Обратите внимание:\n - дата начала события должна быть не ранее чем за час от даты публикации.\n- событие должно быть в состоянии ожидания публикации"
          },
          "response": []
        },
        {
          "name": "Публикация отмененного события",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        let event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                  "        event = await api.rejectEvent(event.id);\r",
                  "        pm.collectionVariables.set(\"eid\", event.id)\r",
                  "        pm.request.body.update({\r",
                  "            mode: 'raw',\r",
                  "            raw: JSON.stringify({\r",
                  "                stateAction : \"PUBLISH_EVENT\"\r",
                  "            }),\r",
                  "            options: { raw: { language: 'json' } }\r",
                  "        });\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            // выполняем наш скрипт\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 409 и данные в формате json\", function () {\r",
                  "    pm.response.to.have.status(409);\r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "PATCH",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "body": {
              "mode": "raw",
              "raw": "{{request_body}}"
            },
            "url": {
              "raw": "{{baseUrl}}/admin/events/:eventId",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "admin",
                "events",
                ":eventId"
              ],
              "variable": [
                {
                  "key": "eventId",
                  "value": "{{eid}}",
                  "description": "(Required) id события"
                }
              ]
            },
            "description": "Обратите внимание:\n - дата начала события должна быть не ранее чем за час от даты публикации.\n- событие должно быть в состоянии ожидания публикации"
          },
          "response": []
        },
        {
          "name": "Отмена опубликованного события",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        let event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                  "        event = await api.publishEvent(event.id);\r",
                  "        pm.collectionVariables.set(\"eid\", event.id)\r",
                  "        pm.request.body.update({\r",
                  "            mode: 'raw',\r",
                  "            raw: JSON.stringify({\r",
                  "                stateAction : \"REJECT_EVENT\"\r",
                  "            }),\r",
                  "            options: { raw: { language: 'json' } }\r",
                  "        });\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            // выполняем наш скрипт\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 409 и данные в формате json\", function () {\r",
                  "    pm.response.to.have.status(409);\r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "PATCH",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "body": {
              "mode": "raw",
              "raw": "{{request_body}}"
            },
            "url": {
              "raw": "{{baseUrl}}/admin/events/:eventId",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "admin",
                "events",
                ":eventId"
              ],
              "variable": [
                {
                  "key": "eventId",
                  "value": "{{eid}}",
                  "description": "(Required) id события"
                }
              ]
            },
            "description": "Обратите внимание:\n - дата начала события должна быть не ранее чем за час от даты публикации.\n- событие должно быть в состоянии ожидания публикации"
          },
          "response": []
        },
        {
          "name": "Добавление повторного запроса от пользователя на участие в событии",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        let event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                  "        event = await api.publishEvent(event.id);\r",
                  "        const submittedUser = await api.addUser(rnd.getUser());\r",
                  "        await api.publishParticipationRequest(event.id, submittedUser.id);\r",
                  "        pm.request.removeQueryParams(['eventId']);\r",
                  "        pm.request.addQueryParams([`eventId=` + event.id]);\r",
                  "        pm.collectionVariables.set('uid', submittedUser.id);\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            // выполняем наш скрипт\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 409 и данные в формате json\", function () {\r",
                  "    pm.response.to.have.status(409);\r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "POST",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/users/:userId/requests?eventId=0",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "users",
                ":userId",
                "requests"
              ],
              "query": [
                {
                  "key": "eventId",
                  "value": "0",
                  "description": "(Required) id события"
                }
              ],
              "variable": [
                {
                  "key": "userId",
                  "value": "{{uid}}",
                  "description": "(Required) id текущего пользователя"
                }
              ]
            },
            "description": "Обратите внимание:\n- нельзя добавить повторный запрос\n- инициатор события не может добавить запрос на участие в своём событии\n- нельзя участвовать в неопубликованном событии\n- если у события достигнут лимит запросов на участие - необходимо вернуть ошибку\n- если для события отключена пре-модерация запросов на участие, то запрос должен автоматически перейти в состояние подтвержденного"
          },
          "response": []
        },
        {
          "name": "Добавление запроса от инициатора события на участие в нём",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        let event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                  "        event = await api.publishEvent(event.id);\r",
                  "        pm.request.removeQueryParams(['eventId']);\r",
                  "        pm.request.addQueryParams([`eventId=` + event.id]);\r",
                  "        pm.collectionVariables.set('uid', user.id);\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            // выполняем наш скрипт\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 409 и данные в формате json\", function () {\r",
                  "    pm.response.to.have.status(409);\r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "POST",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/users/:userId/requests?eventId=0",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "users",
                ":userId",
                "requests"
              ],
              "query": [
                {
                  "key": "eventId",
                  "value": "0",
                  "description": "(Required) id события"
                }
              ],
              "variable": [
                {
                  "key": "userId",
                  "value": "{{uid}}",
                  "description": "(Required) id текущего пользователя"
                }
              ]
            },
            "description": "Обратите внимание:\n- нельзя добавить повторный запрос\n- инициатор события не может добавить запрос на участие в своём событии\n- нельзя участвовать в неопубликованном событии\n- если у события достигнут лимит запросов на участие - необходимо вернуть ошибку\n- если для события отключена пре-модерация запросов на участие, то запрос должен автоматически перейти в состояние подтвержденного"
          },
          "response": []
        },
        {
          "name": "Добавление запроса на участие в неопубликованном событии",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        const event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                  "        const submittedUser = await api.addUser(rnd.getUser());\r",
                  "        pm.request.removeQueryParams(['eventId']);\r",
                  "        pm.request.addQueryParams([`eventId=` + event.id]);\r",
                  "        pm.collectionVariables.set('uid', submittedUser.id);\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            // выполняем наш скрипт\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 409 и данные в формате json\", function () {\r",
                  "    pm.response.to.have.status(409);\r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "POST",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/users/:userId/requests?eventId=0",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "users",
                ":userId",
                "requests"
              ],
              "query": [
                {
                  "key": "eventId",
                  "value": "0",
                  "description": "(Required) id события"
                }
              ],
              "variable": [
                {
                  "key": "userId",
                  "value": "{{uid}}",
                  "description": "(Required) id текущего пользователя"
                }
              ]
            },
            "description": "Обратите внимание:\n- нельзя добавить повторный запрос\n- инициатор события не может добавить запрос на участие в своём событии\n- нельзя участвовать в неопубликованном событии\n- если у события достигнут лимит запросов на участие - необходимо вернуть ошибку\n- если для события отключена пре-модерация запросов на участие, то запрос должен автоматически перейти в состояние подтвержденного"
          },
          "response": []
        },
        {
          "name": "Добавление запроса на участие в событии, у которого заполнен лимит участников",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        let eventBody = rnd.getEvent(category.id);\r",
                  "        eventBody.participantLimit = 1;\r",
                  "        eventBody.requestModeration = false;\r",
                  "        let event = await api.addEvent(user.id, eventBody);\r",
                  "        event = await api.publishEvent(event.id);\r",
                  "        const submittedUser1 = await api.addUser(rnd.getUser());\r",
                  "        const submittedUser2 = await api.addUser(rnd.getUser());\r",
                  "        await api.publishParticipationRequest(event.id, submittedUser1.id);\r",
                  "        pm.request.removeQueryParams(['eventId']);\r",
                  "        pm.request.addQueryParams([`eventId=` + event.id]);\r",
                  "        pm.collectionVariables.set('uid', submittedUser2.id);\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            // выполняем наш скрипт\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 409 и данные в формате json\", function () {\r",
                  "    pm.response.to.have.status(409);\r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "POST",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/users/:userId/requests?eventId=0",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "users",
                ":userId",
                "requests"
              ],
              "query": [
                {
                  "key": "eventId",
                  "value": "0",
                  "description": "(Required) id события"
                }
              ],
              "variable": [
                {
                  "key": "userId",
                  "value": "{{uid}}",
                  "description": "(Required) id текущего пользователя"
                }
              ]
            },
            "description": "Обратите внимание:\n- нельзя добавить повторный запрос\n- инициатор события не может добавить запрос на участие в своём событии\n- нельзя участвовать в неопубликованном событии\n- если у события достигнут лимит запросов на участие - необходимо вернуть ошибку\n- если для события отключена пре-модерация запросов на участие, то запрос должен автоматически перейти в состояние подтвержденного"
          },
          "response": []
        },
        {
          "name": "Изменение опубликованного события от имени пользователя",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        let event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                  "        event = await api.publishEvent(event.id);\r",
                  "        pm.collectionVariables.set(\"uid\", user.id);\r",
                  "        pm.collectionVariables.set(\"eid\", event.id);\r",
                  "        pm.collectionVariables.set(\"response\", event);\r",
                  "        pm.request.body.update({\r",
                  "            mode: 'raw',\r",
                  "            raw: JSON.stringify({\r",
                  "                eventDate : \"2024-10-11 23:10:05\"\r",
                  "            }),\r",
                  "            options: { raw: { language: 'json' } }\r",
                  "        });\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 409 и данные в формате json\", function () {\r",
                  "    pm.response.to.have.status(409);\r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "PATCH",
            "header": [
              {
                "key": "Content-Type",
                "value": "application/json"
              },
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "body": {
              "mode": "raw",
              "raw": "{{request_body}}",
              "options": {
                "raw": {
                  "language": "json"
                }
              }
            },
            "url": {
              "raw": "{{baseUrl}}/users/:userId/events/:eventId",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "users",
                ":userId",
                "events",
                ":eventId"
              ],
              "variable": [
                {
                  "key": "userId",
                  "value": "{{uid}}",
                  "description": "(Required) id текущего пользователя"
                },
                {
                  "key": "eventId",
                  "value": "{{eid}}",
                  "description": "(Required) id отменяемого события"
                }
              ]
            },
            "description": "Обратите внимание: Отменить можно только событие в состоянии ожидания модерации."
          },
          "response": []
        },
        {
          "name": "Попытка принять заявку на участие в событии, когда лимит уже достигнут",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        let eventBody = rnd.getEvent(category.id);\r",
                  "        eventBody['requestModeration'] = true;\r",
                  "        eventBody['participantLimit'] =  1;\r",
                  "        let event = await api.addEvent(user.id, eventBody);\r",
                  "        event = await api.publishEvent(event.id);\r",
                  "        const submittedUser1 = await api.addUser(rnd.getUser());\r",
                  "        const submittedUser2 = await api.addUser(rnd.getUser());\r",
                  "        const requestToParticipate = await api.publishParticipationRequest(event.id, submittedUser1.id);\r",
                  "        const requestToParticipate2 = await api.publishParticipationRequest(event.id, submittedUser2.id);\r",
                  "        await api.acceptParticipationRequest(event.id, user.id, requestToParticipate.id);\r",
                  "        pm.collectionVariables.set('uid', user.id);\r",
                  "        pm.collectionVariables.set('eid', event.id);\r",
                  "        pm.request.body.update({\r",
                  "            mode: 'raw',\r",
                  "            raw: JSON.stringify({requestIds: [requestToParticipate2.id],\r",
                  "            status:\"CONFIRMED\"}),\r",
                  "            options: { raw: { language: 'json' } }\r",
                  "        });\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            // выполняем наш скрипт\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 409 и данные в формате json\", function () {\r",
                  "    pm.response.to.have.status(409);\r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "PATCH",
            "header": [
              {
                "key": "Content-Type",
                "value": "application/json"
              },
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "body": {
              "mode": "raw",
              "raw": "",
              "options": {
                "raw": {
                  "language": "json"
                }
              }
            },
            "url": {
              "raw": "{{baseUrl}}/users/:userId/events/:eventId/requests",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "users",
                ":userId",
                "events",
                ":eventId",
                "requests"
              ],
              "variable": [
                {
                  "key": "userId",
                  "value": "{{uid}}",
                  "description": "(Required) id текущего пользователя"
                },
                {
                  "key": "eventId",
                  "value": "{{eid}}",
                  "description": "(Required) id события текущего пользователя"
                }
              ]
            },
            "description": "Обратите внимание:\n- если для события лимит заявок равен 0 или отключена пре-модерация заявок, то подтверждение заявок не требуется\n- нельзя подтвердить заявку, если уже достигнут лимит по заявкам на данное событие\n- статус можно изменить только у заявок, находящихся в состоянии ожидания\n- если при подтверждении данной заявки, лимит заявок для события исчерпан, то все неподтверждённые заявки необходимо отклонить"
          },
          "response": []
        },
        {
          "name": "Попытка отменить уже принятую заявку на участие в событии",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        let eventBody = rnd.getEvent(category.id);\r",
                  "        eventBody['requestModeration'] = true;\r",
                  "        eventBody['participantLimit'] =  1;\r",
                  "        let event = await api.addEvent(user.id, eventBody);\r",
                  "        event = await api.publishEvent(event.id);\r",
                  "        const submittedUser = await api.addUser(rnd.getUser());\r",
                  "        const requestToParticipate = await api.publishParticipationRequest(event.id, submittedUser.id);\r",
                  "        await api.acceptParticipationRequest(event.id, user.id, requestToParticipate.id);\r",
                  "        pm.collectionVariables.set('uid', user.id);\r",
                  "        pm.collectionVariables.set('eid', event.id);\r",
                  "        pm.request.body.update({\r",
                  "            mode: 'raw',\r",
                  "            raw: JSON.stringify({requestIds: [requestToParticipate.id],\r",
                  "            status:\"REJECTED\"}),\r",
                  "            options: { raw: { language: 'json' } }\r",
                  "        });\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            // выполняем наш скрипт\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 409 и данные в формате json\", function () {\r",
                  "    pm.response.to.have.status(409);\r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "PATCH",
            "header": [
              {
                "key": "Content-Type",
                "value": "application/json"
              },
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "body": {
              "mode": "raw",
              "raw": "",
              "options": {
                "raw": {
                  "language": "json"
                }
              }
            },
            "url": {
              "raw": "{{baseUrl}}/users/:userId/events/:eventId/requests",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "users",
                ":userId",
                "events",
                ":eventId",
                "requests"
              ],
              "variable": [
                {
                  "key": "userId",
                  "value": "{{uid}}",
                  "description": "(Required) id текущего пользователя"
                },
                {
                  "key": "eventId",
                  "value": "{{eid}}",
                  "description": "(Required) id события текущего пользователя"
                }
              ]
            },
            "description": "Обратите внимание:\n- если для события лимит заявок равен 0 или отключена пре-модерация заявок, то подтверждение заявок не требуется\n- нельзя подтвердить заявку, если уже достигнут лимит по заявкам на данное событие\n- статус можно изменить только у заявок, находящихся в состоянии ожидания\n- если при подтверждении данной заявки, лимит заявок для события исчерпан, то все неподтверждённые заявки необходимо отклонить"
          },
          "response": []
        }
      ]
    },
    {
      "name": "Category",
      "item": [
        {
          "name": "Добавление новой категории",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    let category;\r",
                  "    try {\r",
                  "        category = rnd.getCategory();\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "\r",
                  "    pm.request.body.update({\r",
                  "        mode: 'raw',\r",
                  "        raw: JSON.stringify(category),\r",
                  "        options: { raw: { language: 'json' } }\r",
                  "    });\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 201 и данные в формате json\", function () {\r",
                  "    pm.response.to.have.status(201);\r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});\r",
                  "\r",
                  "const source = JSON.parse(pm.request.body.raw);\r",
                  "const target = pm.response.json();\r",
                  "\r",
                  "pm.test(\"Категория должна содержать поля: id, name\", function () {\r",
                  "pm.expect(target).to.have.property('id');\r",
                  "pm.expect(target).to.have.property('name');\r",
                  "});\r",
                  "\r",
                  "pm.test(\"Данные в ответе должны соответствовать данным в запросе\", function () {\r",
                  "    pm.expect(target.id).to.not.be.null;\r",
                  "    pm.expect(source.name).equal(target.name, 'Название категории должно совпадать с отправленным');\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "POST",
            "header": [
              {
                "key": "Content-Type",
                "value": "application/json"
              },
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "body": {
              "mode": "raw",
              "raw": "{{request_body}}",
              "options": {
                "raw": {
                  "language": "json"
                }
              }
            },
            "url": {
              "raw": "{{baseUrl}}/admin/categories",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "admin",
                "categories"
              ]
            },
            "description": "Обратите внимание: имя категории должно быть уникальным"
          },
          "response": []
        },
        {
          "name": "Получение категорий",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        pm.collectionVariables.set(\"response\", category)\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                  "    pm.response.to.be.ok;    \r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});\r",
                  "\r",
                  "const source = pm.collectionVariables.get('response');\r",
                  "const target = pm.response.json();\r",
                  "let founded;\r",
                  "target.forEach(function(element){if (element.id == source.id) founded = element});\r",
                  "\r",
                  "pm.test(\"Категория должна содержать поля: id, name\", function () {\r",
                  "pm.expect(target[0]).to.have.property('id');\r",
                  "pm.expect(target[0]).to.have.property('name');\r",
                  "});\r",
                  "\r",
                  "pm.test(\"Данные в ответе должны соответствовать данным в запросе\", function () {\r",
                  "    pm.expect(source.id).equal(founded.id, 'Идентификатор категории должен соответствовать идентификатору категории добавленной ранее');\r",
                  "    pm.expect(source.name).equal(founded.name, 'Название категории должно соответствовать названию категории добавленной ранее');\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "GET",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/categories?from=0&size=1000",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "categories"
              ],
              "query": [
                {
                  "key": "from",
                  "value": "0",
                  "description": "количество категорий, которые нужно пропустить для формирования текущего набора"
                },
                {
                  "key": "size",
                  "value": "1000",
                  "description": "количество категорий в наборе"
                }
              ]
            }
          },
          "response": []
        },
        {
          "name": "Получение информации о категории по её идентификатору",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        pm.collectionVariables.set(\"response\", category)\r",
                  "        pm.collectionVariables.set(\"catid\", category.id)\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                  "    pm.response.to.be.ok;    \r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});\r",
                  "\r",
                  "const source = pm.collectionVariables.get('response');\r",
                  "const target = pm.response.json();\r",
                  "\r",
                  "pm.test(\"Категория должна содержать поля: id, name\", function () {\r",
                  "pm.expect(target).to.have.property('id');\r",
                  "pm.expect(target).to.have.property('name');\r",
                  "});\r",
                  "\r",
                  "pm.test(\"Данные в ответе должны соответствовать данным в запросе\", function () {\r",
                  "    pm.expect(source.id).equal(target.id, 'Идентификатор категории должен соответствовать идентификатору в запросе');\r",
                  "    pm.expect(source.name).equal(target.name, 'Название категории должно соответствовать названию категории с указанным идентификатором');\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "GET",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/categories/:catId",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "categories",
                ":catId"
              ],
              "variable": [
                {
                  "key": "catId",
                  "value": "{{catid}}",
                  "description": "(Required) id категории"
                }
              ]
            }
          },
          "response": []
        },
        {
          "name": "Удаление категории",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        const findedCategory = await api.findCategory(category.id);\r",
                  "        pm.collectionVariables.set(\"catid\", category.id)\r",
                  "        pm.collectionVariables.set(\"response\", findedCategory)\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 204\", function () {\r",
                  "    pm.response.to.have.status(204);\r",
                  "});\r",
                  "\r",
                  "source = pm.collectionVariables.get('response');\r",
                  "catId = pm.collectionVariables.get('catid');\r",
                  "\r",
                  "pm.test(\"Категория должна быть найдена до удаления\", function () {\r",
                  "    pm.expect(source.id).equal(catId, 'Идентификтор категории должен совпадать с удаляемым');\r",
                  "});\r",
                  "\r",
                  "pm.sendRequest({\r",
                  "            url: pm.collectionVariables.get(\"baseUrl\") + \"/categories/\" + catId,\r",
                  "            method: 'GET',\r",
                  "        }, (error, response) => {\r",
                  "            pm.test(\"Категория не должна быть найдена после удаления\", function () {\r",
                  "                pm.expect(response.code).to.eql(404);\r",
                  "            });\r",
                  "        });"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "DELETE",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/admin/categories/:catId",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "admin",
                "categories",
                ":catId"
              ],
              "variable": [
                {
                  "key": "catId",
                  "value": "{{catid}}"
                }
              ]
            },
            "description": "Обратите внимание: с категорий не должно быть связано ни одного события."
          },
          "response": []
        },
        {
          "name": "Изменение категории",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "    let category\r",
                  "    try {\r",
                  "        category = await api.addCategory(rnd.getCategory());\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "    pm.collectionVariables.set(\"catid\", Number(category.id))\r",
                  "    pm.request.body.update({\r",
                  "        mode: 'raw',\r",
                  "        raw: JSON.stringify({\r",
                  "            name : rnd.getCategory().name\r",
                  "        }),\r",
                  "        options: { raw: { language: 'json' } }\r",
                  "    });\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                  "    pm.response.to.be.ok;    \r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});\r",
                  "\r",
                  "const source = JSON.parse(pm.request.body.raw);\r",
                  "const target = pm.response.json();\r",
                  "\r",
                  "pm.test(\"Категория должна содержать поля: id, name\", function () {\r",
                  "pm.expect(target).to.have.property('id');\r",
                  "pm.expect(target).to.have.property('name');\r",
                  "});\r",
                  "\r",
                  "pm.test(\"Данные в ответе должны соответствовать данным в запросе\", function () {\r",
                  "    pm.expect(target.id).to.not.be.null;\r",
                  "    pm.expect(source.name).equal(target.name, 'Название категории должно совпадать с отправленным');\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "PATCH",
            "header": [],
            "body": {
              "mode": "raw",
              "raw": "{{request_body}}"
            },
            "url": {
              "raw": "{{baseUrl}}/admin/categories/:catId",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "admin",
                "categories",
                ":catId"
              ],
              "variable": [
                {
                  "key": "catId",
                  "value": "{{catid}}"
                }
              ]
            }
          },
          "response": []
        }
      ]
    },
    {
      "name": "Users",
      "item": [
        {
          "name": "Поиск пользователей",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    let compilation;\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        pm.collectionVariables.set(\"uid\", user.id)\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                  "    pm.response.to.be.ok;    \r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});\r",
                  "\r",
                  "const target = pm.response.json();\r",
                  "\r",
                  "pm.test(\"Пользователи должны содержать поля: id, name, email\", function () {\r",
                  "    pm.expect(target[0]).to.have.property('id');\r",
                  "    pm.expect(target[0]).to.have.property('name');\r",
                  "    pm.expect(target[0]).to.have.property('email');\r",
                  "});\r",
                  "\r",
                  "pm.test(\"Должен быть найден только один пользователь по заданному фильтру\", function () {\r",
                  "    pm.expect(target.length).to.eql(1);\r",
                  "});\r",
                  "\r",
                  "pm.test(\"Данные в ответе должны соответствовать данным в запросе\", function () {\r",
                  "    pm.expect(target[0].id).equal(pm.collectionVariables.get(\"uid\"));\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "GET",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/admin/users?ids={{uid}}",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "admin",
                "users"
              ],
              "query": [
                {
                  "key": "ids",
                  "value": "{{uid}}",
                  "description": "id пользователей"
                },
                {
                  "key": "ids",
                  "value": "-10833646",
                  "description": "id пользователей",
                  "disabled": true
                },
                {
                  "key": "from",
                  "value": "0",
                  "description": "количество элементов, которые нужно пропустить для формирования текущего набора",
                  "disabled": true
                },
                {
                  "key": "size",
                  "value": "10",
                  "description": "количество элементов в наборе",
                  "disabled": true
                }
              ]
            }
          },
          "response": []
        },
        {
          "name": "Добавление нового пользователя",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    let user;\r",
                  "    try {\r",
                  "        user = rnd.getUser();\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "\r",
                  "    pm.request.body.update({\r",
                  "        mode: 'raw',\r",
                  "        raw: JSON.stringify(user),\r",
                  "        options: { raw: { language: 'json' } }\r",
                  "    });\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 201 и данные в формате json\", function () {\r",
                  "    pm.response.to.have.status(201);\r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});\r",
                  "\r",
                  "const source = JSON.parse(pm.request.body.raw);\r",
                  "const target = pm.response.json();\r",
                  "\r",
                  "pm.test(\"Пользователь должен содержать поля: id, name, email\", function () {\r",
                  "pm.expect(target).to.have.property('id');\r",
                  "pm.expect(target).to.have.property('name');\r",
                  "pm.expect(target).to.have.property('email');\r",
                  "});\r",
                  "\r",
                  "pm.test(\"Данные в ответе должны соответствовать данным в запросе\", function () {\r",
                  "    pm.expect(target.id).to.not.be.null;\r",
                  "    pm.expect(source.name).equal(target.name, 'Имя пользователя должно соответствовать отправленному в запросе');\r",
                  "    pm.expect(source.email).equal(target.email, 'Почта пользователя должна соответствовать отправленной в запросе');\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "POST",
            "header": [
              {
                "key": "Content-Type",
                "value": "application/json"
              },
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "body": {
              "mode": "raw",
              "raw": "{{request_body}}",
              "options": {
                "raw": {
                  "language": "json"
                }
              }
            },
            "url": {
              "raw": "{{baseUrl}}/admin/users",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "admin",
                "users"
              ]
            }
          },
          "response": []
        },
        {
          "name": "Удаление пользователя",
          "event": [
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 204\", function () {\r",
                  "    pm.response.to.have.status(204);\r",
                  "});\r",
                  "const source = pm.collectionVariables.get('response');\r",
                  "const userId = pm.collectionVariables.get('uid');\r",
                  "\r",
                  "pm.test(\"Пользователь должен быть найден до выполнения запроса\", function(){\r",
                  "    pm.expect(source.length).to.eql(1);\r",
                  "    pm.expect(source[0].id).to.eql(userId);\r",
                  "});\r",
                  "let body\r",
                  "const req = {\r",
                  "                url: \"http://localhost:8080/admin/users?ids=\" + pm.collectionVariables.get(\"uid\"),\r",
                  "                method: \"GET\",\r",
                  "                body: body == null ? \"\" : JSON.stringify(body),\r",
                  "                header: { \"Content-Type\": \"application/json\" },\r",
                  "            };\r",
                  "pm.sendRequest(req, (error, response) => {\r",
                  "    pm.test(\"Пользователь должен быть удалён после выполнения запроса\", function(){\r",
                  "        pm.expect(response.json().length).to.eql(0);\r",
                  "    });\r",
                  "})"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    let compilation;\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        const foundedUser = await api.findUser(user.id);\r",
                  "        pm.collectionVariables.set(\"uid\", user.id);\r",
                  "        pm.collectionVariables.set(\"response\", foundedUser)\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "DELETE",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/admin/users/:userId",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "admin",
                "users",
                ":userId"
              ],
              "variable": [
                {
                  "key": "userId",
                  "value": "{{uid}}",
                  "description": "(Required) id пользователя"
                }
              ]
            }
          },
          "response": []
        }
      ]
    },
    {
      "name": "Event",
      "item": [
        {
          "name": "Добавление нового события",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    let event;\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        pm.collectionVariables.set(\"uid\", user.id)\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        event = rnd.getEvent(category.id);\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "\r",
                  "    pm.request.body.update({\r",
                  "        mode: 'raw',\r",
                  "        raw: JSON.stringify(event),\r",
                  "        options: { raw: { language: 'json' } }\r",
                  "    });\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 201 и данные в формате json\", function () {\r",
                  "    pm.response.to.have.status(201);  \r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});\r",
                  "\r",
                  "const source = JSON.parse(pm.request.body.raw);\r",
                  "const target = pm.response.json();\r",
                  "\r",
                  "pm.test(\"Событие должно содержать поля: id, title, annotation, category, paid, eventDate, initiator, description, participantLimit, state, createdOn, location, requestModeration\", function () {\r",
                  "pm.expect(target).to.have.property('id');\r",
                  "pm.expect(target).to.have.property('title');\r",
                  "pm.expect(target).to.have.property('annotation');\r",
                  "pm.expect(target).to.have.property('category');\r",
                  "pm.expect(target).to.have.property('paid');\r",
                  "pm.expect(target).to.have.property('eventDate');\r",
                  "pm.expect(target).to.have.property('initiator');\r",
                  "pm.expect(target).to.have.property('description');\r",
                  "pm.expect(target).to.have.property('participantLimit');\r",
                  "pm.expect(target).to.have.property('state');\r",
                  "pm.expect(target).to.have.property('createdOn');\r",
                  "pm.expect(target).to.have.property('location');\r",
                  "pm.expect(target).to.have.property('requestModeration');\r",
                  "});\r",
                  "\r",
                  "pm.test(\"Данные в ответе должны соответствовать данным в запросе\", function () {\r",
                  "    pm.expect(target.id).to.not.be.null;\r",
                  "    pm.expect(target.title).equal(source.title, 'Название события должно соответствовать названию события в запросе');\r",
                  "    pm.expect(target.annotation).equal(source.annotation, 'Аннотация события должна соответствовать аннотации события в запросе');\r",
                  "    pm.expect(target.paid.toString()).equal(source.paid.toString(), 'Стоимость события должна соответствовать стоимости события в запросе');\r",
                  "    pm.expect(target.eventDate).equal(source.eventDate, 'Дата проведения события должна соответствовать дате проведения события в запросе');\r",
                  "    pm.expect(target.description).equal(source.description, 'Описание события должно соответствовать описание события в запросе');\r",
                  "    pm.expect(target.participantLimit.toString()).equal(source.participantLimit.toString(), 'Лимит участников события должно соответствовать лимиту участников события в запросе');\r",
                  "    pm.expect(target.location.lat.toString()).equal(source.location.lat.toString(), 'Широта локации проведения события должна соответствовать широте локации проведения события в запросе');\r",
                  "    pm.expect(target.location.lon.toString()).equal(source.location.lon.toString(), 'Долгота локации проведения события должна соответствовать долготе локации проведения события в запросе');\r",
                  "    pm.expect(target.requestModeration.toString()).equal(source.requestModeration.toString(), 'Необходимость модерации события должна соответствовать необходимости модерации события в запросе');\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "POST",
            "header": [
              {
                "key": "Content-Type",
                "value": "application/json"
              },
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "body": {
              "mode": "raw",
              "raw": "{{request_body}}",
              "options": {
                "raw": {
                  "language": "json"
                }
              }
            },
            "url": {
              "raw": "{{baseUrl}}/users/:userId/events",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "users",
                ":userId",
                "events"
              ],
              "variable": [
                {
                  "key": "userId",
                  "value": "{{uid}}",
                  "description": "(Required) id текущего пользователя"
                }
              ]
            },
            "description": "Обратите внимание: дата и время на которые намечено событие не может быть раньше, чем через два часа от текущего момента"
          },
          "response": []
        },
        {
          "name": "Добавление запроса от текущего пользователя на участие в событии",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        let eventBody = rnd.getEvent(category.id);\r",
                  "        eventBody['requestModeration'] = true\r",
                  "        let event = await api.addEvent(user.id, eventBody);\r",
                  "        event = await api.publishEvent(event.id);\r",
                  "        const submittedUser = await api.addUser(rnd.getUser());\r",
                  "        pm.request.removeQueryParams(['eventId']);\r",
                  "        pm.request.addQueryParams([`eventId=` + event.id]);\r",
                  "        pm.collectionVariables.set('uid', submittedUser.id);\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            // выполняем наш скрипт\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 201 и данные в формате json\", function () {\r",
                  "    pm.response.to.have.status(201);   \r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});\r",
                  "\r",
                  "const target = pm.response.json();\r",
                  "var query = {};\r",
                  "pm.request.url.query.all().forEach((param) => { query[param.key] = param.value});\r",
                  "\r",
                  "pm.test(\"Запрос на участие должен содержать поля: id, requester, event, status, created\", function () {\r",
                  "pm.expect(target).to.have.property('id');\r",
                  "pm.expect(target).to.have.property('requester');\r",
                  "pm.expect(target).to.have.property('event');\r",
                  "pm.expect(target).to.have.property('status');\r",
                  "pm.expect(target).to.have.property('created');\r",
                  "});\r",
                  "\r",
                  "pm.test(\"При создании у запроса на участие должен быть статус PENDING\", function () {\r",
                  "    pm.expect(target.status).equal(\"PENDING\");\r",
                  "});\r",
                  "\r",
                  "pm.test(\"Id ивента в запросе и в ответе должны совпадать\", function () {\r",
                  "    pm.expect(target.event.toString()).equal(query['eventId'].toString());\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "POST",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/users/:userId/requests?eventId=0",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "users",
                ":userId",
                "requests"
              ],
              "query": [
                {
                  "key": "eventId",
                  "value": "0",
                  "description": "(Required) id события"
                }
              ],
              "variable": [
                {
                  "key": "userId",
                  "value": "{{uid}}",
                  "description": "(Required) id текущего пользователя"
                }
              ]
            },
            "description": "Обратите внимание:\n- нельзя добавить повторный запрос\n- инициатор события не может добавить запрос на участие в своём событии\n- нельзя участвовать в неопубликованном событии\n- если у события достигнут лимит запросов на участие - необходимо вернуть ошибку\n- если для события отключена пре-модерация запросов на участие, то запрос должен автоматически перейти в состояние подтвержденного"
          },
          "response": []
        },
        {
          "name": "Поиск событий",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        let event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                  "        event = await api.publishEvent(event.id);\r",
                  "        pm.request.removeQueryParams(['users', 'categories']);\r",
                  "        pm.request.addQueryParams([`users=` + user.id, 'categories=' + category.id]);\r",
                  "        pm.collectionVariables.set('response', event);\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            // выполняем наш скрипт\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                  "    pm.response.to.be.ok;    \r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});\r",
                  "\r",
                  "const source = pm.collectionVariables.get('response');\r",
                  "const target = pm.response.json()[0];\r",
                  "\r",
                  "pm.test(\"Событие должно содержать поля: id, title, annotation, category, paid, eventDate, initiator, views, confirmedRequests, description, participantLimit, state, createdOn, publishedOn, location, requestModeration\", function () {\r",
                  "pm.expect(target).to.have.property('id');\r",
                  "pm.expect(target).to.have.property('title');\r",
                  "pm.expect(target).to.have.property('annotation');\r",
                  "pm.expect(target).to.have.property('category');\r",
                  "pm.expect(target).to.have.property('paid');\r",
                  "pm.expect(target).to.have.property('eventDate');\r",
                  "pm.expect(target).to.have.property('initiator');\r",
                  "pm.expect(target).to.have.property('views');\r",
                  "pm.expect(target).to.have.property('confirmedRequests');\r",
                  "pm.expect(target).to.have.property('description');\r",
                  "pm.expect(target).to.have.property('participantLimit');\r",
                  "pm.expect(target).to.have.property('state');\r",
                  "pm.expect(target).to.have.property('createdOn');\r",
                  "pm.expect(target).to.have.property('publishedOn');\r",
                  "pm.expect(target).to.have.property('location');\r",
                  "pm.expect(target).to.have.property('requestModeration');\r",
                  "});\r",
                  "\r",
                  "pm.test(\"Данные в ответе должны соответствовать данным в запросе\", function () {\r",
                  "    pm.expect(source.annotation).equal(target.annotation, 'Аннотация события должна соответствовать искомому событию');\r",
                  "    pm.expect(source.category.id).equal(target.category.id, 'Идентификатор категории должен соответствовать искомой категории');\r",
                  "    pm.expect(source.paid.toString()).equal(target.paid.toString(), 'Стоимость посещения события должна соответствовать искомому событию');\r",
                  "    pm.expect(source.eventDate).equal(target.eventDate, 'Дата проведения события должна соответствовать дате искомого события');\r",
                  "    pm.expect(source.description).equal(target.description, 'Описание события должно соответствовать искомому событию');\r",
                  "    pm.expect(source.title).equal(target.title, 'Название события должно соответствовать искомому событию');\r",
                  "    pm.expect(source.participantLimit.toString()).equal(target.participantLimit.toString(), 'Число участников события должно соответствовать искомому событию');\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "GET",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/admin/events?users=0&states=PUBLISHED&categories=0&rangeStart=2022-01-06%2013%3A30%3A38&rangeEnd=2097-09-06%2013%3A30%3A38&from=0&size=1000",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "admin",
                "events"
              ],
              "query": [
                {
                  "key": "users",
                  "value": "0",
                  "description": "список id пользователей, чьи события нужно найти"
                },
                {
                  "key": "states",
                  "value": "PUBLISHED",
                  "description": "список состояний в которых находятся искомые события"
                },
                {
                  "key": "categories",
                  "value": "0",
                  "description": "список id категорий в которых будет вестись поиск"
                },
                {
                  "key": "rangeStart",
                  "value": "2022-01-06%2013%3A30%3A38",
                  "description": "дата и время не раньше которых должно произойти событие"
                },
                {
                  "key": "rangeEnd",
                  "value": "2097-09-06%2013%3A30%3A38",
                  "description": "дата и время не позже которых должно произойти событие"
                },
                {
                  "key": "from",
                  "value": "0",
                  "description": "количество событий, которые нужно пропустить для формирования текущего набора"
                },
                {
                  "key": "size",
                  "value": "1000",
                  "description": "количество событий в наборе"
                }
              ]
            },
            "description": "Эндпоинт возвращает полную информацию обо всех событиях подходящих под переданные условия"
          },
          "response": []
        },
        {
          "name": "Получение событий, добавленных текущим пользователем",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        pm.collectionVariables.set(\"uid\", user.id)\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        const event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                  "    pm.response.to.be.ok;    \r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});\r",
                  "\r",
                  "const target = pm.response.json()[0];\r",
                  "\r",
                  "pm.test(\"Событие должно содержать поля: id, title, annotation, category, paid, eventDate\", function () {\r",
                  "    pm.expect(target).to.contain.keys('id', 'title', 'annotation', 'category', 'paid', 'eventDate');\r",
                  "});\r",
                  "\r",
                  "pm.test(\"Данные в ответе должны соответствовать данным в запросе\", function () {\r",
                  "    pm.expect(target.id).to.not.be.null;\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "GET",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/users/:userId/events?from=0&size=1000",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "users",
                ":userId",
                "events"
              ],
              "query": [
                {
                  "key": "from",
                  "value": "0",
                  "description": "количество элементов, которые нужно пропустить для формирования текущего набора"
                },
                {
                  "key": "size",
                  "value": "1000",
                  "description": "количество элементов в наборе"
                }
              ],
              "variable": [
                {
                  "key": "userId",
                  "value": "{{uid}}",
                  "description": "(Required) id текущего пользователя"
                }
              ]
            }
          },
          "response": []
        },
        {
          "name": "Получение событий с возможностью фильтрации",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        let event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                  "        event = await api.publishEvent(event.id);\r",
                  "        pm.request.removeQueryParams(['text', 'categories', 'paid']);\r",
                  "        pm.request.addQueryParams([`text=` + event.annotation, 'categories=' + category.id, 'paid=' + event.paid]);\r",
                  "        pm.collectionVariables.set('response', event);\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            // выполняем наш скрипт\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                  "    pm.response.to.be.ok;    \r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});\r",
                  "\r",
                  "const source = pm.collectionVariables.get('response');\r",
                  "const target = pm.response.json()[0];\r",
                  "\r",
                  "pm.test(\"Событие должно содержать поля: id, title, annotation, category, paid, eventDate, initiator, views, confirmedRequests\", function () {\r",
                  "pm.expect(target).to.have.property('id');\r",
                  "pm.expect(target).to.have.property('title');\r",
                  "pm.expect(target).to.have.property('annotation');\r",
                  "pm.expect(target).to.have.property('category');\r",
                  "pm.expect(target).to.have.property('paid');\r",
                  "pm.expect(target).to.have.property('eventDate');\r",
                  "pm.expect(target).to.have.property('initiator');\r",
                  "pm.expect(target).to.have.property('views');\r",
                  "pm.expect(target).to.have.property('confirmedRequests');\r",
                  "});\r",
                  "\r",
                  "pm.test(\"Данные в ответе должны соответствовать данным в запросе\", function () {\r",
                  "    pm.expect(source.annotation).equal(target.annotation, 'Аннотация события должна соответствовать аннотации события с указанным идентификатором');\r",
                  "    pm.expect(source.category.id).equal(target.category.id, 'Категория события должна соответствовать категории события с указанным идентификатором');\r",
                  "    pm.expect(source.paid.toString()).equal(target.paid.toString(), 'Стоимость события должна соответствовать стоимости события с указанным идентификатором');\r",
                  "    pm.expect(source.eventDate).equal(target.eventDate, 'Дата проведения события должна соответствовать дате проведения события с указанным идентификатором');\r",
                  "    pm.expect(source.title).equal(target.title, 'Название события должно соответствовать названию события с указанным идентификатором');\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "GET",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/events?text=0&categories=0&paid=true&rangeStart=2022-01-06%2013%3A30%3A38&rangeEnd=2097-09-06%2013%3A30%3A38&onlyAvailable=false&sort=EVENT_DATE&from=0&size=1000",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "events"
              ],
              "query": [
                {
                  "key": "text",
                  "value": "0",
                  "description": "текст для поиска в содержимом аннотации и подробном описании события"
                },
                {
                  "key": "categories",
                  "value": "0",
                  "description": "список идентификаторов категорий в которых будет вестись поиск"
                },
                {
                  "key": "paid",
                  "value": "true",
                  "description": "поиск только платных/бесплатных событий"
                },
                {
                  "key": "rangeStart",
                  "value": "2022-01-06%2013%3A30%3A38",
                  "description": "дата и время не раньше которых должно произойти событие"
                },
                {
                  "key": "rangeEnd",
                  "value": "2097-09-06%2013%3A30%3A38",
                  "description": "дата и время не позже которых должно произойти событие"
                },
                {
                  "key": "onlyAvailable",
                  "value": "false",
                  "description": "только события у которых не исчерпан лимит запросов на участие"
                },
                {
                  "key": "sort",
                  "value": "EVENT_DATE",
                  "description": "Вариант сортировки: по дате события или по количеству просмотров"
                },
                {
                  "key": "from",
                  "value": "0",
                  "description": "количество событий, которые нужно пропустить для формирования текущего набора"
                },
                {
                  "key": "size",
                  "value": "1000",
                  "description": "количество событий в наборе"
                }
              ]
            },
            "description": "Обратите внимание: \n- это публичный эндпоинт, соответственно в выдаче должны быть только опубликованные события\n- текстовый поиск (по аннотации и подробному описанию) должен быть без учета регистра букв\n- если в запросе не указан диапазон дат [rangeStart-rangeEnd], то нужно выгружать события, которые произойдут позже текущей даты и времени\n- информация о каждом событии должна включать в себя количество просмотров и количество уже одобренных заявок на участие\n- информацию о том, что по этому эндпоинту был осуществлен и обработан запрос, нужно сохранить в сервисе статистики"
          },
          "response": []
        },
        {
          "name": "Получение подробной информации об опубликованном событии по его идентификатору",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        let event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                  "        event = await api.publishEvent(event.id);\r",
                  "        pm.collectionVariables.set(\"eid\", event.id)\r",
                  "        pm.collectionVariables.set('response', event);\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            // выполняем наш скрипт\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                  "    pm.response.to.be.ok;    \r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});\r",
                  "\r",
                  "const source = pm.collectionVariables.get('response');\r",
                  "const target = pm.response.json();\r",
                  "\r",
                  "pm.test(\"Событие должно содержать поля: id, title, annotation, category, paid, eventDate, initiator, views, confirmedRequests, description, participantLimit, state, createdOn, publishedOn, location, requestModeration\", function () {\r",
                  "pm.expect(target).to.have.property('id');\r",
                  "pm.expect(target).to.have.property('title');\r",
                  "pm.expect(target).to.have.property('annotation');\r",
                  "pm.expect(target).to.have.property('category');\r",
                  "pm.expect(target).to.have.property('paid');\r",
                  "pm.expect(target).to.have.property('eventDate');\r",
                  "pm.expect(target).to.have.property('initiator');\r",
                  "pm.expect(target).to.have.property('views');\r",
                  "pm.expect(target).to.have.property('confirmedRequests');\r",
                  "pm.expect(target).to.have.property('description');\r",
                  "pm.expect(target).to.have.property('participantLimit');\r",
                  "pm.expect(target).to.have.property('state');\r",
                  "pm.expect(target).to.have.property('createdOn');\r",
                  "pm.expect(target).to.have.property('publishedOn');\r",
                  "pm.expect(target).to.have.property('location');\r",
                  "pm.expect(target).to.have.property('requestModeration');\r",
                  "});\r",
                  "\r",
                  "pm.test(\"Данные в ответе должны соответствовать данным в запросе\", function () {\r",
                  "    pm.expect(source.annotation).equal(target.annotation, 'Аннотация события должна соответствовать аннотации события с указанным идентификатором');\r",
                  "    pm.expect(source.category.id).equal(target.category.id, 'Категория события должна соответствовать категории события с указанным идентификатором');\r",
                  "    pm.expect(source.paid.toString()).equal(target.paid.toString(), 'Стоимость события должна соответствовать стоимости события с указанным идентификатором');\r",
                  "    pm.expect(source.eventDate).equal(target.eventDate, 'Дата проведения события должна соответствовать дате проведения события с указанным идентификатором');\r",
                  "    pm.expect(source.description).equal(target.description, 'Описание события должно соответствовать описанию события с указанным идентификатором');\r",
                  "    pm.expect(source.title).equal(target.title, 'Название события должно соответствовать названию события с указанным идентификатором');\r",
                  "    pm.expect(source.participantLimit.toString()).equal(target.participantLimit.toString(), 'Лимит участников события должен соответствовать лимиту участников события с указанным идентификатором');\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "GET",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/events/:id",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "events",
                ":id"
              ],
              "variable": [
                {
                  "key": "id",
                  "value": "{{eid}}",
                  "description": "(Required) id события"
                }
              ]
            },
            "description": "Обратите внимание:\n- событие должно быть опубликовано\n- информация о событии должна включать в себя количество просмотров и количество подтвержденных запросов\n- информацию о том, что по этому эндпоинту был осуществлен и обработан запрос, нужно сохранить в сервисе статистики"
          },
          "response": []
        },
        {
          "name": "Получение полной информации о событии добавленном текущим пользователем",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        pm.collectionVariables.set(\"uid\", user.id)\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        const event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                  "        pm.collectionVariables.set(\"eid\", event.id)\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                  "    pm.response.to.be.ok;    \r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});\r",
                  "\r",
                  "const target = pm.response.json();\r",
                  "\r",
                  "pm.test(\"Событие должно содержать поля: id, title, annotation, category, paid, eventDate, initiator, description, participantLimit, state, createdOn, location, requestModeration\", function () {\r",
                  "pm.expect(target).to.have.property('id');\r",
                  "pm.expect(target).to.have.property('title');\r",
                  "pm.expect(target).to.have.property('annotation');\r",
                  "pm.expect(target).to.have.property('category');\r",
                  "pm.expect(target).to.have.property('paid');\r",
                  "pm.expect(target).to.have.property('eventDate');\r",
                  "pm.expect(target).to.have.property('initiator');\r",
                  "pm.expect(target).to.have.property('description');\r",
                  "pm.expect(target).to.have.property('participantLimit');\r",
                  "pm.expect(target).to.have.property('state');\r",
                  "pm.expect(target).to.have.property('createdOn');\r",
                  "pm.expect(target).to.have.property('location');\r",
                  "pm.expect(target).to.have.property('requestModeration');\r",
                  "});\r",
                  "\r",
                  "pm.test(\"Данные в ответе должны соответствовать данным в запросе\", function () {\r",
                  "    pm.expect(target.id).to.not.be.null;\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "GET",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/users/:userId/events/:eventId",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "users",
                ":userId",
                "events",
                ":eventId"
              ],
              "variable": [
                {
                  "key": "userId",
                  "value": "{{uid}}",
                  "description": "(Required) id текущего пользователя"
                },
                {
                  "key": "eventId",
                  "value": "{{eid}}",
                  "description": "(Required) id события"
                }
              ]
            }
          },
          "response": []
        },
        {
          "name": "Получение информации о заявках текущего пользователя на участие в чужих событиях",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        let eventBody = rnd.getEvent(category.id);\r",
                  "        eventBody['requestModeration'] = true\r",
                  "        let event = await api.addEvent(user.id, eventBody);\r",
                  "        event = await api.publishEvent(event.id);\r",
                  "        const submittedUser = await api.addUser(rnd.getUser());\r",
                  "        const requestToJoin = await api.publishParticipationRequest(event.id, submittedUser.id);\r",
                  "        pm.collectionVariables.set('response', requestToJoin);\r",
                  "        pm.collectionVariables.set('uid', submittedUser.id);\r",
                  "\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            // выполняем наш скрипт\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                  "    pm.response.to.be.ok;    \r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});\r",
                  "\r",
                  "const source = pm.collectionVariables.get('response');\r",
                  "const target = pm.response.json()[0];\r",
                  "\r",
                  "pm.test(\"Запрос на участие должен содержать поля: id, requester, event, status, created\", function () {\r",
                  "pm.expect(target).to.have.property('id');\r",
                  "pm.expect(target).to.have.property('requester');\r",
                  "pm.expect(target).to.have.property('event');\r",
                  "pm.expect(target).to.have.property('status');\r",
                  "pm.expect(target).to.have.property('created');\r",
                  "});\r",
                  "\r",
                  "pm.test(\"Данные в ответе должны соответствовать данным в запросе\", function () {\r",
                  "    pm.expect(source.id).equal(target.id, 'Идентификатор запроса на участие в событии должен соответствовать идентификатору запроса, созданного ранее');\r",
                  "    pm.expect(source.requester).equal(target.requester, 'Пользователя, запрашивающий доступ на участие в событии, должен соответствовать указанному пользователю');\r",
                  "    pm.expect(source.event).equal(target.event, 'Событие, доступ к которому запрашивает пользователь, должно соответствовать событию, доступ к которому пользователь запрашивал доступ ранее');\r",
                  "    pm.expect(source.created).equal(target.created, 'Время создания запроса на участие в событии должно соответствовать времени создания запроса, созданного ранее указанным пользователем');\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "GET",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/users/:userId/requests",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "users",
                ":userId",
                "requests"
              ],
              "variable": [
                {
                  "key": "userId",
                  "value": "{{uid}}",
                  "description": "(Required) id текущего пользователя"
                }
              ]
            }
          },
          "response": []
        },
        {
          "name": "Получение информации о запросах на участие в событии текущего пользователя",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        let eventBody = rnd.getEvent(category.id);\r",
                  "        eventBody['requestModeration'] = true\r",
                  "        let event = await api.addEvent(user.id, eventBody);\r",
                  "        event = await api.publishEvent(event.id);\r",
                  "        const submittedUser = await api.addUser(rnd.getUser());\r",
                  "        const requestToJoin = await api.publishParticipationRequest(event.id, submittedUser.id);\r",
                  "        pm.collectionVariables.set('response', requestToJoin);\r",
                  "        pm.collectionVariables.set('uid', user.id);\r",
                  "        pm.collectionVariables.set('eid', event.id);\r",
                  "\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            // выполняем наш скрипт\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                  "    pm.response.to.be.ok;    \r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});\r",
                  "\r",
                  "const source = pm.collectionVariables.get('response');\r",
                  "const target = pm.response.json()[0];\r",
                  "\r",
                  "pm.test(\"Запрос на участие должен содержать поля: id, requester, event, status, created\", function () {\r",
                  "pm.expect(target).to.have.property('id');\r",
                  "pm.expect(target).to.have.property('requester');\r",
                  "pm.expect(target).to.have.property('event');\r",
                  "pm.expect(target).to.have.property('status');\r",
                  "pm.expect(target).to.have.property('created');\r",
                  "});\r",
                  "\r",
                  "pm.test(\"Данные в ответе должны соответствовать данным в запросе\", function () {\r",
                  "    pm.expect(source.id).equal(target.id, 'Идентификатор запроса на участие в событии должен соответствовать идентификатору запроса на участие в событии указанного пользователя');\r",
                  "    pm.expect(source.requester).equal(target.requester, 'Автор запроса на участие в событии должен соответствовать указанному пользователю');\r",
                  "    pm.expect(source.event).equal(target.event, 'Событие в ответе должно соответствовать событию с запросом на участие от указанного пользователя');\r",
                  "    pm.expect(source.created).equal(target.created, 'Время создания запроса на участие в событии должно соответствовать времени создания запроса на участие в событии указанного пользователя');\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "GET",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/users/:userId/events/:eventId/requests",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "users",
                ":userId",
                "events",
                ":eventId",
                "requests"
              ],
              "variable": [
                {
                  "key": "userId",
                  "value": "{{uid}}",
                  "description": "(Required) id текущего пользователя"
                },
                {
                  "key": "eventId",
                  "value": "{{eid}}",
                  "description": "(Required) id события"
                }
              ]
            }
          },
          "response": []
        },
        {
          "name": "Редактирование данных события и его статуса (отклонение/публикация).",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        let event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                  "        let event2 = rnd.getEvent(category.id)\r",
                  "        event2.stateAction = \"PUBLISH_EVENT\"\r",
                  "        pm.collectionVariables.set('response', event2);\r",
                  "        pm.collectionVariables.set(\"eid\", event.id)\r",
                  "        pm.request.body.update({\r",
                  "            mode: 'raw',\r",
                  "            raw: event2,\r",
                  "            options: { raw: { language: 'json' } }\r",
                  "        });\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            // выполняем наш скрипт\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                  "    pm.response.to.be.ok;    \r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});\r",
                  "\r",
                  "const source = pm.collectionVariables.get('response');\r",
                  "const target = pm.response.json();\r",
                  "\r",
                  "pm.test(\"Событие должно содержать поля: id, title, annotation, category, paid, eventDate, initiator, description, participantLimit, state, createdOn, publishedOn, location, requestModeration\", function () {\r",
                  "pm.expect(target).to.have.property('id');\r",
                  "pm.expect(target).to.have.property('title');\r",
                  "pm.expect(target).to.have.property('annotation');\r",
                  "pm.expect(target).to.have.property('category');\r",
                  "pm.expect(target).to.have.property('paid');\r",
                  "pm.expect(target).to.have.property('eventDate');\r",
                  "pm.expect(target).to.have.property('initiator');\r",
                  "pm.expect(target).to.have.property('description');\r",
                  "pm.expect(target).to.have.property('participantLimit');\r",
                  "pm.expect(target).to.have.property('state');\r",
                  "pm.expect(target).to.have.property('createdOn');\r",
                  "pm.expect(target).to.have.property('publishedOn');\r",
                  "pm.expect(target).to.have.property('location');\r",
                  "pm.expect(target).to.have.property('requestModeration');\r",
                  "});\r",
                  "\r",
                  "pm.test(\"Данные в ответе должны соответствовать данным в запросе\", function () {\r",
                  "    pm.expect(source.annotation).equal(target.annotation, 'Аннотация события должна соответствовать искомому событию');\r",
                  "    pm.expect(source.paid.toString()).equal(target.paid.toString(), 'Стоимость события должна соответствовать искомому событию');\r",
                  "    pm.expect(source.eventDate).equal(target.eventDate, 'Дата проведения события должна соответствовать искомому событию');\r",
                  "    pm.expect(source.description).equal(target.description, 'Описание события должно соответствовать искомому событию');\r",
                  "    pm.expect(source.title).equal(target.title, 'Название события должно соответствовать искомому событию');\r",
                  "    pm.expect(source.participantLimit.toString()).equal(target.participantLimit.toString(), 'Лимит участников события должен соответствовать искомому событию');\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "PATCH",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "body": {
              "mode": "raw",
              "raw": "{{request_body}}"
            },
            "url": {
              "raw": "{{baseUrl}}/admin/events/:eventId",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "admin",
                "events",
                ":eventId"
              ],
              "variable": [
                {
                  "key": "eventId",
                  "value": "{{eid}}",
                  "description": "(Required) id события"
                }
              ]
            },
            "description": "Обратите внимание:\n - дата начала события должна быть не ранее чем за час от даты публикации.\n- событие должно быть в состоянии ожидания публикации"
          },
          "response": []
        },
        {
          "name": "Изменение события добавленного текущим пользователем",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        const event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                  "        pm.collectionVariables.set(\"uid\", user.id);\r",
                  "        pm.collectionVariables.set(\"eid\", event.id);\r",
                  "        pm.collectionVariables.set(\"response\", event);\r",
                  "        pm.request.body.update({\r",
                  "            mode: 'raw',\r",
                  "            raw: JSON.stringify({\r",
                  "                stateAction: \"CANCEL_REVIEW\"\r",
                  "            }),\r",
                  "            options: { raw: { language: 'json' } }\r",
                  "        });\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                  "    pm.response.to.be.ok;    \r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});\r",
                  "\r",
                  "const source = pm.collectionVariables.get(\"response\");\r",
                  "const target = pm.response.json();\r",
                  "\r",
                  "\r",
                  "pm.test(\"Событие должно содержать поля: id, title, annotation, category, paid, eventDate, initiator, description, participantLimit, state, createdOn, location, requestModeration\", function () {\r",
                  "pm.expect(target).to.have.property('id');\r",
                  "pm.expect(target).to.have.property('title');\r",
                  "pm.expect(target).to.have.property('annotation');\r",
                  "pm.expect(target).to.have.property('category');\r",
                  "pm.expect(target).to.have.property('paid');\r",
                  "pm.expect(target).to.have.property('eventDate');\r",
                  "pm.expect(target).to.have.property('initiator');\r",
                  "pm.expect(target).to.have.property('description');\r",
                  "pm.expect(target).to.have.property('participantLimit');\r",
                  "pm.expect(target).to.have.property('state');\r",
                  "pm.expect(target).to.have.property('createdOn');\r",
                  "pm.expect(target).to.have.property('location');\r",
                  "pm.expect(target).to.have.property('requestModeration');\r",
                  "});\r",
                  "\r",
                  "pm.test(\"Данные в ответе должны соответствовать данным в запросе\", function () {\r",
                  "    pm.expect(source.annotation).equal(target.annotation, 'Аннотация отменённого события должна соответствовать аннотации события до отмены');\r",
                  "    pm.expect(source.category.id).equal(target.category.id, 'Категория отменённого события должна соответствовать категории события до отмены');\r",
                  "    pm.expect(source.paid.toString()).equal(target.paid.toString(), 'Стоимость отменённого события должна соответствовать стоимости события до отмены');\r",
                  "    pm.expect(source.eventDate).equal(target.eventDate, 'Дата проведения отменённого события должна соответствовать дате проведения события до отмены');\r",
                  "    pm.expect(source.description).equal(target.description, 'Описание отменённого события должно соответствовать описанию события до отмены');\r",
                  "    pm.expect(source.title).equal(target.title, 'Название отменённого события должно соответствовать названию события до отмены');\r",
                  "    pm.expect(source.participantLimit.toString()).equal(target.participantLimit.toString(), 'Лимит участников отменённого события должен соответствовать лимиту участников события до отмены');\r",
                  "    pm.expect(source.paid.toString()).equal(target.paid.toString(), 'Стоимость отменённого события должна соответствовать стоимости события до отмены');\r",
                  "});\r",
                  "\r",
                  "pm.test(\"Событие должно иметь статус PENDING при создании и статус CANCELED после выполнения запроса\", function () {\r",
                  "    pm.expect(source.state).equal(\"PENDING\");\r",
                  "    pm.expect(target.state).equal(\"CANCELED\");\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "PATCH",
            "header": [
              {
                "key": "Content-Type",
                "value": "application/json"
              },
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "body": {
              "mode": "raw",
              "raw": "{{request_body}}",
              "options": {
                "raw": {
                  "language": "json"
                }
              }
            },
            "url": {
              "raw": "{{baseUrl}}/users/:userId/events/:eventId",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "users",
                ":userId",
                "events",
                ":eventId"
              ],
              "variable": [
                {
                  "key": "userId",
                  "value": "{{uid}}",
                  "description": "(Required) id текущего пользователя"
                },
                {
                  "key": "eventId",
                  "value": "{{eid}}",
                  "description": "(Required) id отменяемого события"
                }
              ]
            },
            "description": "Обратите внимание: Отменить можно только событие в состоянии ожидания модерации."
          },
          "response": []
        },
        {
          "name": "Отмена своего запроса на участие в событии",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        let eventBody = rnd.getEvent(category.id);\r",
                  "        eventBody['requestModeration'] = true\r",
                  "        let event = await api.addEvent(user.id, eventBody);\r",
                  "        event = await api.publishEvent(event.id);\r",
                  "        const submittedUser = await api.addUser(rnd.getUser());\r",
                  "        const requestToJoin = await api.publishParticipationRequest(event.id, submittedUser.id);\r",
                  "        pm.collectionVariables.set('response', requestToJoin);\r",
                  "        pm.collectionVariables.set('uid', submittedUser.id);\r",
                  "        pm.collectionVariables.set('reqid', requestToJoin.id);\r",
                  "\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            // выполняем наш скрипт\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                  "    pm.response.to.be.ok;    \r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});\r",
                  "\r",
                  "const target = pm.response.json();\r",
                  "const source = pm.collectionVariables.get('response');\r",
                  "\r",
                  "pm.test(\"Запрос на участие должен содержать поля: id, requester, event, status, created\", function () {\r",
                  "pm.expect(target).to.have.property('id');\r",
                  "pm.expect(target).to.have.property('requester');\r",
                  "pm.expect(target).to.have.property('event');\r",
                  "pm.expect(target).to.have.property('status');\r",
                  "pm.expect(target).to.have.property('created');\r",
                  "});\r",
                  "\r",
                  "pm.test(\"При создании у запроса на участие должен быть статус PENDING, а при удалении - CANCELED\", function () {\r",
                  "    pm.expect(source.status).equal(\"PENDING\");\r",
                  "    pm.expect(target.status).equal(\"CANCELED\");\r",
                  "});\r",
                  "\r",
                  "pm.test(\"Данные в ответе должны соответствовать данным в запросе\", function () {\r",
                  "    pm.expect(source.id).equal(target.id, 'Идентификатор отменённого запроса на участие в событии должен соответствовать идентификатору запроса до отмены');\r",
                  "    pm.expect(source.requester).equal(target.requester, 'Пользователь, отменяющий запрос на участие в событии, должен соответствовать текущему пользователю');\r",
                  "    pm.expect(source.event).equal(target.event, 'Событие отменённого запроса на участие должно соответствовать запросу на участие в событии до отмены');\r",
                  "    pm.expect(source.created).equal(target.created, 'Дата создания отменённого запроса на участие в событии должна соответствовать дате создания запроса до отмены');\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "PATCH",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/users/:userId/requests/:requestId/cancel",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "users",
                ":userId",
                "requests",
                ":requestId",
                "cancel"
              ],
              "variable": [
                {
                  "key": "userId",
                  "value": "{{uid}}",
                  "description": "(Required) id текущего пользователя"
                },
                {
                  "key": "requestId",
                  "value": "{{reqid}}",
                  "description": "(Required) id запроса на участие"
                }
              ]
            }
          },
          "response": []
        },
        {
          "name": "Отклонение запроса на участие в событии",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        let eventBody = rnd.getEvent(category.id);\r",
                  "        eventBody['requestModeration'] = true\r",
                  "        let event = await api.addEvent(user.id, eventBody);\r",
                  "        event = await api.publishEvent(event.id);\r",
                  "        const submittedUser = await api.addUser(rnd.getUser());\r",
                  "        const requestToJoin = await api.publishParticipationRequest(event.id, submittedUser.id);\r",
                  "        pm.collectionVariables.set('response', requestToJoin);\r",
                  "        pm.collectionVariables.set('uid', user.id);\r",
                  "        pm.collectionVariables.set('eid', event.id);\r",
                  "        pm.request.body.update({\r",
                  "            mode: 'raw',\r",
                  "            raw: JSON.stringify({requestIds: [requestToJoin.id],\r",
                  "            status:\"REJECTED\"}),\r",
                  "            options: { raw: { language: 'json' } }\r",
                  "        });\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            // выполняем наш скрипт\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                  "    pm.response.to.be.ok;    \r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});\r",
                  "\r",
                  "const source = pm.collectionVariables.get('response');\r",
                  "const target = pm.response.json()[\"rejectedRequests\"][0];\r",
                  "\r",
                  "pm.test(\"Запрос на участие должен содержать поля: id, requester, event, status, created\", function () {\r",
                  "pm.expect(target).to.have.property('id');\r",
                  "pm.expect(target).to.have.property('requester');\r",
                  "pm.expect(target).to.have.property('event');\r",
                  "pm.expect(target).to.have.property('status');\r",
                  "pm.expect(target).to.have.property('created');\r",
                  "});\r",
                  "\r",
                  "pm.test(\"Данные в ответе должны соответствовать данным в запросе\", function () {\r",
                  "    pm.expect(source.id).equal(target.id, 'Идентификатор запроса на участие в событии должен соответствовать идентификатору запроса на участие в событии указанного пользователя');\r",
                  "    pm.expect(source.requester).equal(target.requester, 'Пользователь, запрашивающий доступ на участие в событии должен пользователю, отправившему запрос на участие в событии указанного пользователя ранее');\r",
                  "    pm.expect(source.event).equal(target.event, 'Событие, запрос на участие в котором надо подтвердить, должно соответствовать событию указанного пользователя');\r",
                  "    pm.expect(source.created).equal(target.created, 'Время создания запроса на участие в событии после подтверждения должно соответствовать времени создания запроса на участие в событии указанного пользователя до подтверждения');\r",
                  "});\r",
                  "\r",
                  "pm.test(\"Запрос на участие должен иметь статус PENDING при создании и статус REJECTED после выполнения запроса\", function () {\r",
                  "    pm.expect(source.status).equal(\"PENDING\");\r",
                  "    pm.expect(target.status).equal(\"REJECTED\");\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "PATCH",
            "header": [
              {
                "key": "Content-Type",
                "value": "application/json"
              },
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "body": {
              "mode": "raw",
              "raw": "{\n  \"requestIds\": [\n    1,\n    2,\n    3\n  ],\n  \"status\": \"CONFIRMED\"\n}",
              "options": {
                "raw": {
                  "language": "json"
                }
              }
            },
            "url": {
              "raw": "{{baseUrl}}/users/:userId/events/:eventId/requests",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "users",
                ":userId",
                "events",
                ":eventId",
                "requests"
              ],
              "variable": [
                {
                  "key": "userId",
                  "value": "{{uid}}",
                  "description": "(Required) id текущего пользователя"
                },
                {
                  "key": "eventId",
                  "value": "{{eid}}",
                  "description": "(Required) id события текущего пользователя"
                }
              ]
            },
            "description": "Обратите внимание:\n- если для события лимит заявок равен 0 или отключена пре-модерация заявок, то подтверждение заявок не требуется\n- нельзя подтвердить заявку, если уже достигнут лимит по заявкам на данное событие\n- статус можно изменить только у заявок, находящихся в состоянии ожидания\n- если при подтверждении данной заявки, лимит заявок для события исчерпан, то все неподтверждённые заявки необходимо отклонить"
          },
          "response": []
        },
        {
          "name": "Изменение статуса (подтверждена, отменена) заявок на участие в событии текущего пользователя",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        let eventBody = rnd.getEvent(category.id);\r",
                  "        eventBody['requestModeration'] = true\r",
                  "        let event = await api.addEvent(user.id, eventBody);\r",
                  "        event = await api.publishEvent(event.id);\r",
                  "        const submittedUser = await api.addUser(rnd.getUser());\r",
                  "        const requestToJoin = await api.publishParticipationRequest(event.id, submittedUser.id);\r",
                  "        pm.collectionVariables.set('response', requestToJoin);\r",
                  "        pm.collectionVariables.set('uid', user.id);\r",
                  "        pm.collectionVariables.set('eid', event.id);\r",
                  "        pm.request.body.update({\r",
                  "            mode: 'raw',\r",
                  "            raw: JSON.stringify({requestIds: [requestToJoin.id],\r",
                  "            status:\"CONFIRMED\"}),\r",
                  "            options: { raw: { language: 'json' } }\r",
                  "        });\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            // выполняем наш скрипт\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                  "    pm.response.to.be.ok;    \r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});\r",
                  "\r",
                  "const source = pm.collectionVariables.get('response');\r",
                  "const target = pm.response.json()[\"confirmedRequests\"][0];\r",
                  "\r",
                  "pm.test(\"Запрос на участие должен содержать поля: id, requester, event, status, created\", function () {\r",
                  "pm.expect(target).to.have.property('id');\r",
                  "pm.expect(target).to.have.property('requester');\r",
                  "pm.expect(target).to.have.property('event');\r",
                  "pm.expect(target).to.have.property('status');\r",
                  "pm.expect(target).to.have.property('created');\r",
                  "});\r",
                  "\r",
                  "pm.test(\"Данные в ответе должны соответствовать данным в запросе\", function () {\r",
                  "    pm.expect(source.id).equal(target.id, 'Идентификатор запроса на участие в событии должен соответствовать идентификатору запроса на участие в событии указанного пользователя');\r",
                  "    pm.expect(source.requester).equal(target.requester, 'Пользователь, запрашивающий доступ на участие в событии должен пользователю, отправившему запрос на участие в событии указанного пользователя ранее');\r",
                  "    pm.expect(source.event).equal(target.event, 'Событие, запрос на участие в котором надо подтвердить, должно соответствовать событию указанного пользователя');\r",
                  "    pm.expect(source.created).equal(target.created, 'Время создания запроса на участие в событии после подтверждения должно соответствовать времени создания запроса на участие в событии указанного пользователя до подтверждения');\r",
                  "});\r",
                  "\r",
                  "pm.test(\"Запрос на участие должен иметь статус PENDING при создании и статус CONFIRMED после выполнения запроса\", function () {\r",
                  "    pm.expect(source.status).equal(\"PENDING\");\r",
                  "    pm.expect(target.status).equal(\"CONFIRMED\");\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "PATCH",
            "header": [
              {
                "key": "Content-Type",
                "value": "application/json"
              },
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "body": {
              "mode": "raw",
              "raw": "",
              "options": {
                "raw": {
                  "language": "json"
                }
              }
            },
            "url": {
              "raw": "{{baseUrl}}/users/:userId/events/:eventId/requests",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "users",
                ":userId",
                "events",
                ":eventId",
                "requests"
              ],
              "variable": [
                {
                  "key": "userId",
                  "value": "{{uid}}",
                  "description": "(Required) id текущего пользователя"
                },
                {
                  "key": "eventId",
                  "value": "{{eid}}",
                  "description": "(Required) id события текущего пользователя"
                }
              ]
            },
            "description": "Обратите внимание:\n- если для события лимит заявок равен 0 или отключена пре-модерация заявок, то подтверждение заявок не требуется\n- нельзя подтвердить заявку, если уже достигнут лимит по заявкам на данное событие\n- статус можно изменить только у заявок, находящихся в состоянии ожидания\n- если при подтверждении данной заявки, лимит заявок для события исчерпан, то все неподтверждённые заявки необходимо отклонить"
          },
          "response": []
        }
      ]
    },
    {
      "name": "Compilation",
      "item": [
        {
          "name": "Добавление новой подборки",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    let compilation;\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        const event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                  "        compilation = rnd.getCompilation(event.id);\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "\r",
                  "    pm.request.body.update({\r",
                  "        mode: 'raw',\r",
                  "        raw: JSON.stringify(compilation),\r",
                  "        options: { raw: { language: 'json' } }\r",
                  "    });\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 201 и данные в формате json\", function () {\r",
                  "    pm.response.to.have.status(201);\r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});\r",
                  "\r",
                  "const source = JSON.parse(pm.request.body.raw);\r",
                  "const target = pm.response.json();\r",
                  "\r",
                  "pm.test(\"Подборка должны содержать поля: id, title, pinned, events\", function () {\r",
                  "pm.expect(target).to.have.property('id');\r",
                  "pm.expect(target).to.have.property('title');\r",
                  "pm.expect(target).to.have.property('pinned');\r",
                  "pm.expect(target).to.have.property('events');\r",
                  "});\r",
                  "\r",
                  "pm.test(\"Данные в ответе должны соответствовать данным в запросе\", function () {\r",
                  "    pm.expect(target.id).to.not.be.null;\r",
                  "    pm.expect(target.title).to.be.a(\"string\");\r",
                  "    pm.expect(target.events).to.be.an(\"array\");\r",
                  "\r",
                  "    pm.expect(source.events[0]).equal(target.events[0].id, 'Идентификаторы событий в подборке должен быть идентичен идентификаторам, указанным при создании подборки ');\r",
                  "    pm.expect(source.title).equal(target.title, 'Название подборки должно соответствовать указанному при создании');\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "POST",
            "header": [
              {
                "key": "Content-Type",
                "value": "application/json"
              },
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "body": {
              "mode": "raw",
              "raw": "",
              "options": {
                "raw": {
                  "language": "json"
                }
              }
            },
            "url": {
              "raw": "{{baseUrl}}/admin/compilations",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "admin",
                "compilations"
              ]
            }
          },
          "response": []
        },
        {
          "name": "Получение подборки событий по её id",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        const compilation = await api.addCompilation(rnd.getCompilation());\r",
                  "        pm.collectionVariables.set('response', compilation);\r",
                  "        pm.collectionVariables.set('compid', compilation.id);\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            // выполняем наш скрипт\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                  "    pm.response.to.be.ok;    \r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});\r",
                  "\r",
                  "const source = pm.collectionVariables.get('response');\r",
                  "const target = pm.response.json();\r",
                  "\r",
                  "pm.test(\"Подборка должны содержать поля: id, title, pinned, events\", function () {\r",
                  "pm.expect(target).to.have.property('id');\r",
                  "pm.expect(target).to.have.property('title');\r",
                  "pm.expect(target).to.have.property('pinned');\r",
                  "pm.expect(target).to.have.property('events');\r",
                  "});\r",
                  "\r",
                  "pm.test(\"Данные в ответе должны соответствовать данным в запросе\", function () {\r",
                  "    pm.expect(source.id).equal(target.id, 'Идентификатор подборки должен соответствовать идентификатору подборки добавленной ранее');\r",
                  "    pm.expect(source.title).equal(target.title, 'Название подборки должно соответствовать названию подборки добавленной ранее');\r",
                  "    pm.expect(source.pinned).equal(target.pinned, 'Закреплённость подборки должна соответствовать закреплённости подборки добавленной ранее');\r",
                  "    pm.expect(source.events.join()).equal(target.events.join(), 'События подборки должны соответствовать событиям подборки добавленной ранее');\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "GET",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/compilations/:compId",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "compilations",
                ":compId"
              ],
              "variable": [
                {
                  "key": "compId",
                  "value": "{{compid}}",
                  "description": "(Required) id подборки"
                }
              ]
            }
          },
          "response": []
        },
        {
          "name": "Получение подборок событий",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        let newComp = rnd.getCompilation();\r",
                  "        newComp['pinned'] = true;\r",
                  "        const compilation = await api.addCompilation(newComp);\r",
                  "        pm.collectionVariables.set('response', compilation);\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            // выполняем наш скрипт\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 200 и данные в формате json\", function () {\r",
                  "    pm.response.to.be.ok;    \r",
                  "    pm.response.to.be.withBody;\r",
                  "    pm.response.to.be.json;\r",
                  "});\r",
                  "\r",
                  "const source = pm.collectionVariables.get('response');\r",
                  "const target = pm.response.json();\r",
                  "let founded;\r",
                  "target.forEach(function(element){if (element.id == source.id) founded = element});\r",
                  "\r",
                  "pm.test(\"Подборка должны содержать поля: id, title, pinned, events\", function () {\r",
                  "pm.expect(target[0]).to.have.property('id');\r",
                  "pm.expect(target[0]).to.have.property('title');\r",
                  "pm.expect(target[0]).to.have.property('pinned');\r",
                  "pm.expect(target[0]).to.have.property('events');\r",
                  "});\r",
                  "\r",
                  "pm.test(\"Данные в ответе должны соответствовать данным в запросе\", function () {\r",
                  "    pm.expect(source.id).equal(founded.id, 'Идентификатор подборки должен соответствовать идентификатору подборки добавленной ранее');\r",
                  "    pm.expect(source.title).equal(founded.title, 'Название подборки должно соответствовать названию подборки добавленной ранее');\r",
                  "    pm.expect(source.pinned).equal(founded.pinned, 'Закрепленность подборки должна соответствовать закрепленности подборки добавленной ранее');\r",
                  "    pm.expect(source.events.join()).equal(founded.events.join(), 'События подборки должны соответствовать событиям подборки добавленной ранее');\r",
                  "});"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "GET",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/compilations?pinned=true&from=0&size=1000",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "compilations"
              ],
              "query": [
                {
                  "key": "pinned",
                  "value": "true",
                  "description": "искать только закрепленные/не закрепленные подборки"
                },
                {
                  "key": "from",
                  "value": "0",
                  "description": "количество элементов, которые нужно пропустить для формирования текущего набора"
                },
                {
                  "key": "size",
                  "value": "1000",
                  "description": "количество элементов в наборе"
                }
              ]
            }
          },
          "response": []
        },
        {
          "name": "Удаление подборки",
          "event": [
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 204\", function () {\r",
                  "    pm.response.to.have.status(204);\r",
                  "});\r",
                  "\r",
                  "let source = pm.collectionVariables.get('response');\r",
                  "\r",
                  "pm.test(\"Подборка должна быть найдена до удаления\", function () {\r",
                  "    pm.expect(source).not.to.be.null;\r",
                  "});\r",
                  "\r",
                  "let body\r",
                  "const req = {\r",
                  "                url: \"http://localhost:8080/compilations?from=0&size=1000\" + pm.collectionVariables.get(\"uid\"),\r",
                  "                method: \"GET\",\r",
                  "                body: body == null ? \"\" : JSON.stringify(body),\r",
                  "                header: { \"Content-Type\": \"application/json\" },\r",
                  "            };\r",
                  "pm.sendRequest(req, (error, response) => {\r",
                  "    pm.test(\"Подборка должна быть удалена после выполнения запроса\", function(){\r",
                  "        response.json().forEach(element => {\r",
                  "            if(element.id == pm.collectionVariables.get('compid')){\r",
                  "                throw new Error(\"Подборка все еще находится в списке существующих\");\r",
                  "            }\r",
                  "        })\r",
                  "    });\r",
                  "})\r",
                  ""
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        const compilation = await api.addCompilation(rnd.getCompilation());\r",
                  "        const foundedCompilation = await api.findCompilation(compilation.id);\r",
                  "        pm.collectionVariables.set('compid', compilation.id);\r",
                  "        pm.collectionVariables.set('response', foundedCompilation);\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            // выполняем наш скрипт\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "DELETE",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/admin/compilations/:compId",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "admin",
                "compilations",
                ":compId"
              ],
              "variable": [
                {
                  "key": "compId",
                  "value": "{{compid}}",
                  "description": "(Required) id подборки"
                }
              ]
            }
          },
          "response": []
        },
        {
          "name": "Обновить информацию о подборке",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const main = async () => {\r",
                  "    const api = new API(pm);\r",
                  "    const rnd = new RandomUtils();\r",
                  "\r",
                  "    try {\r",
                  "        const user = await api.addUser(rnd.getUser());\r",
                  "        const category = await api.addCategory(rnd.getCategory());\r",
                  "        let event = await api.addEvent(user.id, rnd.getEvent(category.id));\r",
                  "        event = await api.publishEvent(event.id);\r",
                  "        const compilation = await api.addCompilation(rnd.getCompilation());\r",
                  "        const foundedCompilation = await api.findCompilation(compilation.id);\r",
                  "        pm.collectionVariables.set('compid', compilation.id);\r",
                  "        pm.collectionVariables.set('response', foundedCompilation);\r",
                  "        pm.collectionVariables.set('eid', event.id);\r",
                  "        pm.request.body.update({\r",
                  "            mode: 'raw',\r",
                  "            raw: JSON.stringify({\r",
                  "                events : [event.id],\r",
                  "                pinned: true,\r",
                  "                title: rnd.getCompilation().name\r",
                  "            }),\r",
                  "            options: { raw: { language: 'json' } }\r",
                  "        });\r",
                  "    } catch(err) {\r",
                  "        console.error(\"Ошибка при подготовке тестовых данных.\", err);\r",
                  "    }\r",
                  "};\r",
                  "\r",
                  "const interval = setInterval(() => {}, 1000);\r",
                  "\r",
                  "setTimeout(async () => \r",
                  "    {\r",
                  "        try {\r",
                  "            // выполняем наш скрипт\r",
                  "            await main();\r",
                  "        } catch (e) {\r",
                  "            console.error(e);\r",
                  "        } finally {\r",
                  "            clearInterval(interval);\r",
                  "        }\r",
                  "    },  \r",
                  "    100 \r",
                  ");"
                ],
                "type": "text/javascript"
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test(\"Ответ должен содержать код статуса 200\", function () {\r",
                  "    pm.response.to.be.ok;    \r",
                  "});\r",
                  "\r",
                  "source = pm.collectionVariables.get('response');\r",
                  "compId = pm.collectionVariables.get('compid');\r",
                  "eventId = pm.collectionVariables.get('eid');\r",
                  "\r",
                  "pm.test(\"Событие не должно быть найдено в подборке до добавления\", function () {\r",
                  "    pm.expect(source.events.length).equal(0);\r",
                  "});\r",
                  "\r",
                  "pm.sendRequest({\r",
                  "            url: pm.collectionVariables.get(\"baseUrl\") + \"/compilations/\" + compId,\r",
                  "            method: 'GET',\r",
                  "        }, (error, response) => {\r",
                  "            \r",
                  "            pm.test(\"Событие должно быть найдено в подборке после добавления\", function () {\r",
                  "                pm.expect(response.json().events[0].id).equal(eventId);\r",
                  "            });\r",
                  "        });"
                ],
                "type": "text/javascript"
              }
            }
          ],
          "request": {
            "method": "PATCH",
            "header": [],
            "body": {
              "mode": "raw",
              "raw": "{{request_body}}"
            },
            "url": {
              "raw": "{{baseUrl}}/admin/compilations/:compId",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "admin",
                "compilations",
                ":compId"
              ],
              "variable": [
                {
                  "key": "compId",
                  "value": "{{compid}}"
                }
              ]
            }
          },
          "response": []
        }
      ]
    }
  ],
  "event": [
    {
      "listen": "prerequest",
      "script": {
        "type": "text/javascript",
        "exec": [
          "API = class {",
          "    constructor(postman, verbose = false, baseUrl = \"http://localhost:8080\") {",
          "        this.baseUrl = baseUrl;",
          "        this.pm = postman;",
          "        this._verbose = verbose;",
          "    }",
          "",
          "    async addUser(user, verbose=null) {",
          "        return this.post(\"/admin/users\", user, \"Ошибка при добавлении нового пользователя: \", verbose);",
          "    }",
          "",
          "    async addCategory(category, verbose=null) {",
          "        return this.post(\"/admin/categories\", category, \"Ошибка при добавлении новой категории: \", verbose);",
          "    }",
          "",
          "    async addEvent(userId, event, verbose=null) {",
          "        return this.post(\"/users/\" + userId + \"/events\", event, \"Ошибка при добавлении нового события: \", verbose);",
          "    }",
          "",
          "    async addCompilation(compilation, verbose=null) {",
          "        return this.post(\"/admin/compilations\", compilation, \"Ошибка при добавлении новой подборки: \", verbose);",
          "    }",
          "",
          "    async publishParticipationRequest(eventId, userId, verbose=null) {",
          "        return this.post('/users/' + userId + '/requests?eventId=' + eventId, null, \"Ошибка при добавлении нового запроса на участие в событии\", verbose);",
          "    }",
          "",
          "    async publishEvent(eventId, verbose=null) {",
          "        return this.patch('/admin/events/' + eventId, {stateAction: \"PUBLISH_EVENT\"}, \"Ошибка при публикации события\", verbose);",
          "    }",
          "    ",
          "    async rejectEvent(eventId, verbose=null) {",
          "        return this.patch('/admin/events/' + eventId, {stateAction: \"REJECT_EVENT\"}, \"Ошибка при отмене события\", verbose);",
          "    }",
          "",
          "    async acceptParticipationRequest(eventId, userId, reqId, verbose=null) {",
          "        return this.patch('/users/' + userId + '/events/' + eventId + '/requests/', {requestIds:[reqId], status: \"CONFIRMED\"}, \"Ошибка при принятии заявки на участие в событии\", verbose);",
          "    }",
          "",
          "    async findCategory(catId, verbose=null) {",
          "        return this.get('/categories/' + catId, null, \"Ошибка при поиске категории по id\", verbose);",
          "    }",
          "",
          "    async findCompilation(compId, verbose=null) {",
          "        return this.get('/compilations/' + compId, null, \"Ошибка при поиске подборки по id\", verbose);",
          "    }",
          "",
          "    async findEvent(eventId, verbose=null) {",
          "        return this.get('/events/' + eventId, null, \"Ошибка при поиске события по id\", verbose);",
          "    }",
          "",
          "    async findUser(userId, verbose=null) {",
          "        return this.get('/admin/users?ids=' + userId, null, \"Ошибка при поиске пользователя по id\", verbose);",
          "    }",
          "",
          "    async post(path, body, errorText = \"Ошибка при выполнении post-запроса: \", verbose=null) {",
          "        return this.sendRequest(\"POST\", path, body, errorText, verbose);",
          "    }",
          "",
          "    async patch(path, body = null, errorText = \"Ошибка при выполнении patch-запроса: \", verbose=null) {",
          "        return this.sendRequest(\"PATCH\", path, body, errorText, verbose);",
          "    }",
          "",
          "    async get(path, body = null, errorText = \"Ошибка при выполнении get-запроса: \", verbose=null) {",
          "        return this.sendRequest(\"GET\", path, body, errorText, verbose);",
          "    }",
          "",
          "    async sendRequest(method, path, body=null, errorText = \"Ошибка при выполнении запроса: \", verbose=null) {",
          "        return new Promise((resolve, reject) => {",
          "            verbose = verbose == null ? this._verbose : verbose;",
          "",
          "            const request = {",
          "                url: this.baseUrl + path,",
          "                method: method,",
          "                body: body == null ? \"\" : JSON.stringify(body),",
          "                header: { \"Content-Type\": \"application/json\" },",
          "            };",
          "",
          "            if(verbose) {",
          "                console.log(\"Отправляю запрос: \", request);",
          "            }",
          "",
          "            try {",
          "                this.pm.sendRequest(request, (error, response) => {",
          "                    if(error || (response.code >= 400 && response.code <= 599)) {",
          "                        let err = error ? error : JSON.stringify(response.json());",
          "                        console.error(\"При выполнении запроса к серверу возникла ошика.\\n\", err,",
          "                             \"\\nДля отладки проблемы повторите такой же запрос к вашей программе \" + ",
          "                             \"на локальном компьютере. Данные запроса:\\n\", JSON.stringify(request));",
          "",
          "                        reject(new Error(errorText + err));",
          "                    }",
          "",
          "                    if(verbose) {",
          "                        console.log(\"Результат обработки запроса: код состояния - \", response.code, \", тело: \", response.json());",
          "                    }",
          "",
          "                    resolve(response.json());",
          "                });",
          "            } catch(err) {",
          "                if(verbose) {",
          "                    console.error(errorText, err);",
          "                }",
          "                return Promise.reject(err);",
          "            }",
          "        });",
          "    }",
          "};",
          "",
          "RandomUtils = class {",
          "    constructor() {}",
          "",
          "    getUser() {",
          "        return {",
          "            name: pm.variables.replaceIn('{{$randomFullName}}'),",
          "            email: pm.variables.replaceIn('{{$randomEmail}}')",
          "        };",
          "    }",
          "",
          "    getCategory() {",
          "        return {",
          "            name: pm.variables.replaceIn('{{$randomWord}}') + Math.floor(Math.random() * 100).toString()",
          "        };",
          "    }",
          "",
          "    getEvent(categoryId) {",
          "        return {",
          "            annotation: pm.variables.replaceIn('{{$randomLoremParagraph}}'),",
          "            category: categoryId,",
          "            description: pm.variables.replaceIn('{{$randomLoremParagraphs}}'),",
          "            eventDate: this.getFutureDateTime(),",
          "            location: {",
          "                lat: parseFloat(pm.variables.replaceIn('{{$randomLatitude}}')),",
          "                lon: parseFloat(pm.variables.replaceIn('{{$randomLongitude}}')),",
          "            },",
          "            paid: pm.variables.replaceIn('{{$randomBoolean}}'),",
          "            participantLimit: pm.variables.replaceIn('{{$randomInt}}'),",
          "            requestModeration: pm.variables.replaceIn('{{$randomBoolean}}'),",
          "            title: pm.variables.replaceIn('{{$randomLoremSentence}}'),",
          "        }",
          "    }",
          "",
          "    getCompilation(...eventIds) {",
          "        return {",
          "            title: pm.variables.replaceIn('{{$randomLoremSentence}}').slice(0, 50),",
          "            pinned: pm.variables.replaceIn('{{$randomBoolean}}'),",
          "            events: eventIds",
          "        };",
          "    }",
          "",
          "",
          "    getFutureDateTime(hourShift = 5, minuteShift=0, yearShift=0) {",
          "        let moment = require('moment');",
          "",
          "        let m = moment();",
          "        m.add(hourShift, 'hour');",
          "        m.add(minuteShift, 'minute');",
          "        m.add(yearShift, 'year');",
          "",
          "        return m.format('YYYY-MM-DD HH:mm:ss');",
          "    }",
          "",
          "    getWord(length = 1) {",
          "        let result = '';",
          "        const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';",
          "        const charactersLength = characters.length;",
          "        let counter = 0;",
          "        while (counter < length) {",
          "            result += characters.charAt(Math.floor(Math.random() * charactersLength));",
          "            counter += 1;",
          "        }",
          "        return result;",
          "    }",
          "}"
        ]
      }
    },
    {
      "listen": "test",
      "script": {
        "type": "text/javascript",
        "exec": [
          ""
        ]
      }
    }
  ],
  "variable": [
    {
      "key": "baseUrl",
      "value": "http://localhost:8080",
      "type": "string"
    },
    {
      "key": "name",
      "value": ""
    },
    {
      "key": "usersCount",
      "value": 1,
      "type": "number"
    },
    {
      "key": "catid",
      "value": 1,
      "type": "number"
    },
    {
      "key": "request_body",
      "value": ""
    },
    {
      "key": "mail",
      "value": ""
    },
    {
      "key": "response",
      "value": ""
    },
    {
      "key": "uid",
      "value": 1,
      "type": "number"
    },
    {
      "key": "catname",
      "value": ""
    },
    {
      "key": "eid",
      "value": 1,
      "type": "number"
    },
    {
      "key": "compid",
      "value": 1,
      "type": "number"
    },
    {
      "key": "toCheck",
      "value": ""
    },
    {
      "key": "newDataToSet",
      "value": ""
    },
    {
      "key": "uid1",
      "value": ""
    },
    {
      "key": "reqid",
      "value": 1,
      "type": "number"
    },
    {
      "key": "catId",
      "value": ""
    },
    {
      "key": "confirmedRequests",
      "value": ""
    },
    {
      "key": "responseArr",
      "value": ""
    },
    {
      "key": "source1",
      "value": ""
    },
    {
      "key": "source2",
      "value": ""
    },
    {
      "key": "fromId",
      "value": "0"
    },
    {
      "key": "source",
      "value": ""
    }
  ]
}
